eventsource-parser 3.1.0: ParseError

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 eventsource-parser.ParseError in pkg:npm/eventsource-parser@3.1.0
Kind: HOW

Use EXACTLY these public packages and versions:
  - pkg:npm/eventsource-parser@3.1.0
Demonstrate these symbols/APIs:
  - eventsource-parser.ParseError

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:edad70e9503ff92a529ce13350be43eb50761eb158e9cb5c938f20dc2fdc454f","contract":["assert ParseError can be instantiated directly with error message and options including type field and value","assert createParser emits ParseError with type unknown-field on unrecognized directives","assert createParser emits ParseError with type invalid-retry when retry interval is non-numeric","assert createParser emits ParseError with type max-buffer-size-exceeded when stream chunk exceeds configured buffer limit"],"goal":"verify eventsource-parser.ParseError in pkg:npm/eventsource-parser@3.1.0","kind":"HOW","packages":["pkg:npm/eventsource-parser@3.1.0"],"schemaVersion":1,"symbols":["eventsource-parser.ParseError"]},"contractCommand":["node","test/contract.mjs"],"environment":{"arch":"x64","distro":"ubuntu","ecosystem":"npm","libc":"glibc","libcVersion":"2.39","os":"linux","osVersionBucket":"24","packageManager":"npm","schemaVersion":1},"license":"MIT-0","packages":["pkg:npm/eventsource-parser@3.1.0"],"schemaVersion":1,"subject":"pkg:npm/eventsource-parser@3.1.0","symbols":["eventsource-parser.ParseError"],"verifierAdapter":"node-typescript@1"}

import { ParseError, createParser } from 'eventsource-parser';

/**
 * Parses an SSE stream payload and captures any ParseError instances emitted.
 * @param {string} input - Raw SSE stream payload
 * @param {import('eventsource-parser').ParserConfig} [config] - Optional parser configuration
 * @returns {{ events: import('eventsource-parser').EventSourceMessage[], errors: ParseError[] }}
 */
export function parseSSEWithErrors(input, config = {}) {
  const events = [];
  const errors = [];
  const parser = createParser({
    ...config,
    onEvent: (event) => {
      events.push(event);
      config.onEvent?.(event);
    },
    onError: (err) => {
      errors.push(err);
      config.onError?.(err);
    },
  });
  parser.feed(input);
  return { events, errors };
}

export { ParseError, createParser };
export default ParseError;

{
  "name": "sample-eventsource-parser-error",
  "version": "1.0.0",
  "lockfileVersion": 3,
  "requires": true,
  "packages": {
    "": {
      "name": "sample-eventsource-parser-error",
      "version": "1.0.0",
      "dependencies": {
        "eventsource-parser": "3.1.0"
      }
    },
    "node_modules/eventsource-parser": {
      "version": "3.1.0",
      "resolved": "https://registry.npmjs.org/eventsource-parser/-/eventsource-parser-3.1.0.tgz",
      "integrity": "sha512-kJezFj9YFAMLeORyi7aCLxLbD5/qWMQnoMVlVPyHIll7lgRJCc3JVln9Vgl9nwQi0YkMnhdGTMNn7CkRRAptMg==",
      "license": "MIT",
      "engines": {
        "node": ">=18.0.0"
      }
    }
  }
}

{
  "name": "sample-eventsource-parser-error",
  "version": "1.0.0",
  "private": true,
  "type": "module",
  "dependencies": {
    "eventsource-parser": "3.1.0"
  }
}

{
  "schemaVersion": 1,
  "goal": "verify eventsource-parser.ParseError in pkg:npm/eventsource-parser@3.1.0",
  "kind": "HOW",
  "packages": [
    "pkg:npm/eventsource-parser@3.1.0"
  ],
  "symbols": [
    "eventsource-parser.ParseError"
  ]
}

import assert from 'node:assert/strict';
import { ParseError, createParser, parseSSEWithErrors } from '../index.mjs';

// 1. assert ParseError can be instantiated directly with error message and options including type field and value
{
  const err = new ParseError('Custom unknown field', {
    type: 'unknown-field',
    field: 'foo',
    value: 'bar',
    line: 'foo: bar',
  });

  assert.ok(err instanceof Error);
  assert.ok(err instanceof ParseError);
  assert.strictEqual(err.message, 'Custom unknown field');
  assert.strictEqual(err.type, 'unknown-field');
  assert.strictEqual(err.field, 'foo');
  assert.strictEqual(err.value, 'bar');
  assert.strictEqual(err.line, 'foo: bar');
}

// 2. assert createParser emits ParseError with type unknown-field on unrecognized directives
{
  const { events, errors } = parseSSEWithErrors('invalid_key: some_value\ndata: payload\n\n');

  assert.strictEqual(events.length, 1);
  assert.strictEqual(events[0].data, 'payload');

  assert.strictEqual(errors.length, 1);
  const err = errors[0];
  assert.ok(err instanceof ParseError);
  assert.strictEqual(err.type, 'unknown-field');
  assert.strictEqual(err.field, 'invalid_key');
  assert.strictEqual(err.value, 'some_value');
  assert.strictEqual(err.line, 'invalid_key: some_value');
}

// 3. assert createParser emits ParseError with type invalid-retry when retry interval is non-numeric
{
  const { events, errors } = parseSSEWithErrors('retry: abc\ndata: test\n\n');

  assert.strictEqual(events.length, 1);
  assert.strictEqual(events[0].data, 'test');

  assert.strictEqual(errors.length, 1);
  const err = errors[0];
  assert.ok(err instanceof ParseError);
  assert.strictEqual(err.type, 'invalid-retry');
  assert.strictEqual(err.value, 'abc');
  assert.strictEqual(err.line, 'retry: abc');
}

// 4. assert createParser emits ParseError with type max-buffer-size-exceeded when stream chunk exceeds configured buffer limit
{
  const errors = [];
  const parser = createParser({
    maxBufferSize: 20,
    onError: (err) => errors.push(err),
  });

  parser.feed('data: this is an overly long stream message that exceeds buffer limit');

  assert.strictEqual(errors.length, 1);
  const err = errors[0];
  assert.ok(err instanceof ParseError);
  assert.strictEqual(err.type, 'max-buffer-size-exceeded');

  // Verify that feed throws after exceeding buffer size
  assert.throws(
    () => parser.feed('data: next chunk'),
    /terminated after exceeding the configured max buffer size/
  );

  // Verify reset allows parsing again
  parser.reset();
  const resetEvents = [];
  const resetParser = createParser({
    maxBufferSize: 50,
    onEvent: (e) => resetEvents.push(e),
  });
  resetParser.feed('data: valid\n\n');
  assert.strictEqual(resetEvents.length, 1);
  assert.strictEqual(resetEvents[0].data, 'valid');
}

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