eventsource-parser 3.1.1: createParser

Clean-room public code sample — generation instructions

Write a brand-new, minimal, self-contained code sample in this clean-room directory.
Do not copy, paraphrase, or reference any existing project source. Work only from this spec.

A csx.json manifest scaffold already exists. Do not recreate it from memory. Preserve its case.goal, packages and symbols; fill its empty case.contract with exact assertions and correct its environment, commands and verifierAdapter for the files you generate.

Goal: verify createParser in pkg:npm/eventsource-parser@3.1.1
Kind: HOW

Use EXACTLY these public packages and versions:
  - pkg:npm/eventsource-parser@3.1.1
Demonstrate these symbols/APIs:
  - createParser
Constraints:
  - executionContext: node
Required runtime conditions:
  - ecosystem: npm
  - language: javascript
  - moduleSystem: cjs
  - packageManager: npm@10.9.8
  - runtime: node@22.23.2

Rules:
  - One focused purpose; the smallest project that proves the goal.
  - Include a contract test (test/contract.*) that runs OFFLINE and exits 0 exactly when the goal behavior works.
  - Pin every dependency with a lockfile so resolution is reproducible.
  - No secrets, credentials, or tokens. No real URLs (only example.com or localhost). No absolute paths.
  - No personal names, emails, company names, or project identifiers of any kind.
  - No binaries and no generated output (node_modules, dist, target, venv, .git, .env).
  - Keep it under 200 files and 256KB packed.

{"case":{"caseId":"case:sha256:2e3c0cfee888a11ea503e1f5824210cb4a7bc9261affb2440ed7d302c88b33b6","constraints":{"executionContext":"node"},"contract":["assert createParser parses standard SSE data events with id, event, and data fields","assert createParser handles multiline data payloads concatenated with newline","assert createParser handles streaming chunks across multiple feed calls","assert createParser triggers onRetry callback when receiving retry field","assert createParser triggers onComment callback for comment lines","assert createParser triggers onError callback with ParseError for unknown fields","assert createParser triggers onError when maxBufferSize limit is exceeded","assert reset clears buffered state and parser continues with new events","assert createParser requires a config object and rejects function argument directly"],"goal":"verify createParser in pkg:npm/eventsource-parser@3.1.1","kind":"HOW","packages":["pkg:npm/eventsource-parser@3.1.1"],"schemaVersion":1,"symbols":["createParser"]},"contractCommand":["node","test/contract.mjs"],"environment":{"arch":"x64","distro":"ubuntu","ecosystem":"npm","executionContext":"node","language":"javascript","libc":"glibc","libcVersion":"2.39","moduleSystem":"cjs","os":"linux","osVersionBucket":"24","packageManager":"npm","packageManagerVersion":"10.9.8","runtime":"node","runtimeVersion":"22.23.2","schemaVersion":1},"license":"MIT-0","packages":["pkg:npm/eventsource-parser@3.1.1"],"schemaVersion":1,"subject":"pkg:npm/eventsource-parser@3.1.1","symbols":["createParser"],"verifierAdapter":"node-typescript@1"}

const { createParser, ParseError } = require('eventsource-parser');

function createEventParser(config) {
  return createParser(config);
}

function parseStreamChunks(chunks, config) {
  const parser = createParser(config);
  for (const chunk of chunks) {
    parser.feed(chunk);
  }
  return parser;
}

module.exports = {
  createParser,
  ParseError,
  createEventParser,
  parseStreamChunks,
};

{
  "name": "sample-eventsource-parser",
  "version": "1.0.0",
  "lockfileVersion": 3,
  "requires": true,
  "packages": {
    "": {
      "name": "sample-eventsource-parser",
      "version": "1.0.0",
      "license": "MIT-0",
      "dependencies": {
        "eventsource-parser": "3.1.1"
      }
    },
    "node_modules/eventsource-parser": {
      "version": "3.1.1",
      "resolved": "https://registry.npmjs.org/eventsource-parser/-/eventsource-parser-3.1.1.tgz",
      "integrity": "sha512-EKN1vKAMcZ8MlYMpaNuxN6R9yakzH6uajHcHVTqWJzvu5pWw9DyhbP35HH8MVBQ+dZjAfDxk+A8NiR9KWaXiyQ==",
      "license": "MIT",
      "engines": {
        "node": ">=18.0.0"
      }
    }
  }
}

{
  "name": "sample-eventsource-parser",
  "version": "1.0.0",
  "description": "Minimal clean-room sample verifying createParser in eventsource-parser",
  "main": "index.js",
  "license": "MIT-0",
  "dependencies": {
    "eventsource-parser": "3.1.1"
  }
}

{
  "schemaVersion": 1,
  "goal": "verify createParser in pkg:npm/eventsource-parser@3.1.1",
  "kind": "HOW",
  "packages": [
    "pkg:npm/eventsource-parser@3.1.1"
  ],
  "symbols": [
    "createParser"
  ],
  "constraints": {
    "executionContext": "node"
  },
  "runtimeConditions": {
    "ecosystem": "npm",
    "language": "javascript",
    "moduleSystem": "cjs",
    "packageManager": "npm@10.9.8",
    "runtime": "node@22.23.2"
  }
}

import assert from 'node:assert';
import { createParser, ParseError, createEventParser, parseStreamChunks } from '../index.js';

// 1. assert createParser parses standard SSE data events with id, event, and data fields
{
  const events = [];
  const parser = createEventParser({
    onEvent: (e) => events.push(e),
  });
  parser.feed('id: 42\nevent: user-joined\ndata: Alice\n\n');
  assert.strictEqual(events.length, 1, 'Should emit one event');
  assert.strictEqual(events[0].id, '42', 'Should have id 42');
  assert.strictEqual(events[0].event, 'user-joined', 'Should have event type user-joined');
  assert.strictEqual(events[0].data, 'Alice', 'Should have data Alice');
}

// 2. assert createParser handles multiline data payloads concatenated with newline
{
  const events = [];
  const parser = createEventParser({
    onEvent: (e) => events.push(e),
  });
  parser.feed('data: first line\ndata: second line\n\n');
  assert.strictEqual(events.length, 1, 'Should emit one event');
  assert.strictEqual(events[0].data, 'first line\nsecond line', 'Multiline data should be joined with newline');
  assert.strictEqual(events[0].id, undefined, 'id should be undefined when omitted');
  assert.strictEqual(events[0].event, undefined, 'event should be undefined when omitted');
}

// 3. assert createParser handles streaming chunks across multiple feed calls
{
  const events = [];
  const parser = createEventParser({
    onEvent: (e) => events.push(e),
  });
  parser.feed('data: part');
  assert.strictEqual(events.length, 0, 'Incomplete message should not emit event');
  parser.feed('ial me');
  assert.strictEqual(events.length, 0, 'Incomplete message should not emit event');
  parser.feed('ssage\n\n');
  assert.strictEqual(events.length, 1, 'Complete message should emit event');
  assert.strictEqual(events[0].data, 'partial message', 'Streamed chunks should be assembled');
}

// 4. assert createParser triggers onRetry callback when receiving retry field
{
  const retries = [];
  const parser = createEventParser({
    onRetry: (r) => retries.push(r),
  });
  parser.feed('retry: 3000\n\n');
  assert.deepStrictEqual(retries, [3000], 'onRetry should receive retry duration in ms');
}

// 5. assert createParser triggers onComment callback for comment lines
{
  const comments = [];
  const parser = createEventParser({
    onComment: (c) => comments.push(c),
  });
  parser.feed(': keepalive ping\n\n');
  assert.deepStrictEqual(comments, ['keepalive ping'], 'onComment should receive stripped comment text');
}

// 6. assert createParser triggers onError callback with ParseError for unknown fields
{
  const errors = [];
  const parser = createEventParser({
    onError: (err) => errors.push(err),
  });
  parser.feed('custom_field: some_value\n\n');
  assert.strictEqual(errors.length, 1, 'onError should be called on invalid/unknown fields');
  assert.ok(errors[0] instanceof ParseError || errors[0].name === 'ParseError', 'Error should be a ParseError');
  assert.strictEqual(errors[0].type, 'unknown-field', 'Error type should be unknown-field');
  assert.strictEqual(errors[0].field, 'custom_field', 'Error field should be custom_field');
  assert.strictEqual(errors[0].value, 'some_value', 'Error value should be some_value');
}

// 7. assert createParser triggers onError when maxBufferSize limit is exceeded
{
  const errors = [];
  const parser = createEventParser({
    maxBufferSize: 10,
    onError: (err) => errors.push(err),
  });
  parser.feed('data: 123456789012345');
  assert.strictEqual(errors.length, 1, 'onError should be called when buffer limit is exceeded');
  assert.strictEqual(errors[0].type, 'max-buffer-size-exceeded', 'Error type should be max-buffer-size-exceeded');
  assert.throws(
    () => {
      parser.feed('more data');
    },
    /Cannot feed parser: it was terminated/,
    'Feeding a terminated parser should throw an error'
  );
}

// 8. assert reset clears buffered state and parser continues with new events
{
  const events = [];
  const parser = createEventParser({
    onEvent: (e) => events.push(e),
  });
  parser.feed('data: incomplete discarded data');
  parser.reset();
  parser.feed('data: fresh start message\n\n');
  assert.strictEqual(events.length, 1, 'Reset should drop previous incomplete state');
  assert.strictEqual(events[0].data, 'fresh start message', 'New event after reset should be parsed');
}

// 9. assert createParser requires a config object and rejects function argument directly
{
  assert.throws(
    () => {
      createParser(() => {});
    },
    {
      name: 'TypeError',
      message: /`config` must be an object/,
    },
    'createParser must throw TypeError when function is passed instead of config object'
  );
}

console.log('All createParser contract assertions passed.');