@attestry/sdk 0.6.0

package/dist/ndjson-parser.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Async generator: reads from a stream of UTF-8-encoded NDJSON bytes
+ * and yields each parsed JSON value. Ends when the underlying reader
+ * signals `done`. Defensive: a caller that breaks early out of the
+ * for-await loop leaves the reader open — call `reader.cancel()` from
+ * your finally block (or use `parseNDJSONResponse` below which handles
+ * cleanup automatically).
+ *
+ * Mid-stream read errors are wrapped as
+ * `AttestryError("network error during stream: <reason>")` with the
+ * original error chained as `cause`. AbortError-shaped rejects (caller
+ * cancelled the underlying signal) are wrapped as
+ * `AttestryError("request aborted by caller")` for symmetry with the
+ * pre-fetch abort surface. The resource layer can rely on these
+ * wrappings — `runDecisionsExport`'s catch passes any `AttestryError`
+ * through verbatim.
+ *
+ * @throws AttestryError if a JSON line fails to parse, OR the residual
+ *         line buffer exceeds `maxLineBytes` (defense against unbounded-
+ *         line DoS), OR the underlying reader rejects mid-iteration
+ *         (network drop, abort).
+ */
+export declare function parseNDJSON(reader: ReadableStreamDefaultReader<Uint8Array>, options?: {
+    maxLineBytes?: number;
+}): AsyncGenerator<unknown, void, unknown>;
+/**
+ * Convenience wrapper around `parseNDJSON` that accepts a `Response`,
+ * derives the reader, and ALWAYS calls `reader.cancel()` in a `finally`
+ * block — including when a caller breaks out of the for-await loop
+ * early. Without this, an early `break` leaks the underlying connection.
+ *
+ * Resources should call this rather than `parseNDJSON` directly.
+ *
+ * Symmetric to `parseSSEResponse`.
+ */
+export declare function parseNDJSONResponse(response: Response, options?: {
+    maxLineBytes?: number;
+}): AsyncGenerator<unknown, void, unknown>;
+/**
+ * Trim a single trailing `\r` (CR). Defensive: NDJSON spec mandates LF
+ * only, but a Windows-tooling artifact could leave a CR before the LF.
+ * Trimming exactly one CR keeps the parser permissive without treating
+ * CR alone as a line separator.
+ */
+declare function stripTrailingCR(s: string): string;
+/**
+ * Parse one trimmed line as JSON. Throws `AttestryError` (with the
+ * underlying error as `cause`) if the payload isn't valid JSON.
+ */
+declare function parseLine(line: string): unknown;
+export declare const __test__: {
+    DEFAULT_MAX_LINE_BYTES: number;
+    parseLine: typeof parseLine;
+    stripTrailingCR: typeof stripTrailingCR;
+};
+export {};
+//# sourceMappingURL=ndjson-parser.d.ts.map

package/dist/ndjson-parser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ndjson-parser.d.ts","sourceRoot":"","sources":["../src/ndjson-parser.ts"],"names":[],"mappings":"AAmDA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAuB,WAAW,CAChC,MAAM,EAAE,2BAA2B,CAAC,UAAU,CAAC,EAC/C,OAAO,GAAE;IAAE,YAAY,CAAC,EAAE,MAAM,CAAA;CAAO,GACtC,cAAc,CAAC,OAAO,EAAE,IAAI,EAAE,OAAO,CAAC,CAqGxC;AAED;;;;;;;;;GASG;AACH,wBAAuB,mBAAmB,CACxC,QAAQ,EAAE,QAAQ,EAClB,OAAO,GAAE;IAAE,YAAY,CAAC,EAAE,MAAM,CAAA;CAAO,GACtC,cAAc,CAAC,OAAO,EAAE,IAAI,EAAE,OAAO,CAAC,CAmBxC;AAID;;;;;GAKG;AACH,iBAAS,eAAe,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAE1C;AAmBD;;;GAGG;AACH,iBAAS,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAcxC;AAGD,eAAO,MAAM,QAAQ;;;;CAIpB,CAAC"}

package/dist/ndjson-parser.js

@@ -0,0 +1,245 @@
+// ─── NDJSON parser ──────────────────────────────────────────────────────────
+//
+// Parses application/x-ndjson (newline-delimited JSON) streams. One JSON
+// value per `\n`-delimited line. Symmetric to `sse-parser.ts` but
+// simpler — no event/id/data headers, no multi-line frame join, no
+// optional retry: hint.
+//
+// Used by streaming endpoints whose payload is a sequence of opaque JSON
+// frames (today: `decisions.export`; future: `audit-log/export`,
+// `bundles/export`). The parser yields raw `unknown` values; the
+// resource-level caller validates frame shape.
+//
+// Spec:
+//   https://github.com/ndjson/ndjson-spec
+//
+// Subset implemented:
+//   - One JSON value per line, separated by U+000A LINE FEED (`\n`).
+//   - UTF-8 decoded with `{stream: true}` so multibyte chars split
+//     across reads recombine correctly.
+//   - Leading BOM (U+FEFF) stripped once at stream start.
+//   - Blank lines silently skipped (lenient — kernel doesn't emit them
+//     but defensive parsers should tolerate whitespace).
+//   - Final unterminated line (no trailing `\n`) is emitted (lenient —
+//     handles HTTP/1.1 connection-close mid-line).
+//   - Buffer cap (1 MiB default) on the residual partial-line buffer,
+//     defending against an unbounded line attack.
+//
+// Subset deliberately NOT implemented:
+//   - `\r` / `\r\n` line endings — strict NDJSON spec mandates `\n`
+//     only. The parser trims trailing `\r` defensively before parsing
+//     (Windows-tooling artifact) but does NOT treat `\r` alone as a
+//     line separator.
+//   - Comment lines — ndjson has no comment syntax.
+import { AttestryError } from "./errors.js";
+/**
+ * Maximum residual buffer size before the parser bails. Defends against
+ * a server / proxy emitting an unbounded line (no `\n` boundary) — the
+ * parser would otherwise accumulate until OOM.
+ *
+ * 1 MiB is generous: the kernel's `decisions.export` per-record line is
+ * ~1 KB today (a record with empty jsonb arrays serialises near 500
+ * bytes; with claims/invocations populated, ~2 KB). 1 MiB is ~1000×
+ * headroom.
+ *
+ * Configurable via `parseNDJSON`'s `maxLineBytes` option for callers
+ * with legitimate large-line use cases (none today).
+ */
+const DEFAULT_MAX_LINE_BYTES = 1024 * 1024;
+/**
+ * Async generator: reads from a stream of UTF-8-encoded NDJSON bytes
+ * and yields each parsed JSON value. Ends when the underlying reader
+ * signals `done`. Defensive: a caller that breaks early out of the
+ * for-await loop leaves the reader open — call `reader.cancel()` from
+ * your finally block (or use `parseNDJSONResponse` below which handles
+ * cleanup automatically).
+ *
+ * Mid-stream read errors are wrapped as
+ * `AttestryError("network error during stream: <reason>")` with the
+ * original error chained as `cause`. AbortError-shaped rejects (caller
+ * cancelled the underlying signal) are wrapped as
+ * `AttestryError("request aborted by caller")` for symmetry with the
+ * pre-fetch abort surface. The resource layer can rely on these
+ * wrappings — `runDecisionsExport`'s catch passes any `AttestryError`
+ * through verbatim.
+ *
+ * @throws AttestryError if a JSON line fails to parse, OR the residual
+ *         line buffer exceeds `maxLineBytes` (defense against unbounded-
+ *         line DoS), OR the underlying reader rejects mid-iteration
+ *         (network drop, abort).
+ */
+export async function* parseNDJSON(reader, options = {}) {
+    const maxLineBytes = options.maxLineBytes ?? DEFAULT_MAX_LINE_BYTES;
+    const decoder = new TextDecoder("utf-8");
+    let buffer = "";
+    let bomStripped = false;
+    while (true) {
+        let result;
+        try {
+            result = await reader.read();
+        }
+        catch (err) {
+            // Mid-stream reader rejects: TCP RST, proxy hang-up, signal-
+            // aborted fetch. Wrap with a clear AttestryError so consumers
+            // can branch uniformly via `instanceof AttestryError` rather
+            // than having to type-narrow on raw DOMException / TypeError.
+            // Resource-layer wrapper passes AttestryError through verbatim.
+            if (isAbortErrorShape(err)) {
+                throw new AttestryError("request aborted by caller", { cause: err });
+            }
+            throw new AttestryError(`network error during stream: ${err instanceof Error ? err.message : String(err)}`, { cause: err });
+        }
+        const { value, done } = result;
+        if (done) {
+            // Flush any final bytes (no-op if value was always complete).
+            buffer += decoder.decode();
+            // Per NDJSON spec, the final newline is optional — emit any
+            // trailing partial line if non-empty after trimming. This handles
+            // HTTP/1.1 connection-close mid-line: better to surface the
+            // partial frame to the caller (who can then validate its shape)
+            // than silently drop it.
+            const trimmed = stripTrailingCR(buffer).trim();
+            if (trimmed.length > 0)
+                yield parseLine(trimmed);
+            return;
+        }
+        if (value === undefined)
+            continue;
+        // `{stream: true}` carries multi-byte UTF-8 boundaries across chunks.
+        buffer += decoder.decode(value, { stream: true });
+        // Strip a leading BOM (U+FEFF) if present. Kernel doesn't emit a
+        // BOM today, but a misconfigured proxy / charset transcoder could
+        // prepend one. Without this strip, the first frame's first char
+        // would be `{` and `JSON.parse` would throw with an
+        // unhelpful "unexpected character" error. One-shot: only at the
+        // very first decoded codepoint of the stream.
+        //
+        // Hostile-review fix: `bomStripped` is now only flipped once we've
+        // actually decoded at least one character. Otherwise an empty /
+        // partial-multibyte first read would set the flag prematurely; if
+        // the BOM bytes (or a continuation that the decoder treats as
+        // mid-stream-data BOM) arrived in a later read, the strip-attempt
+        // would be skipped. Defense-in-depth — `String.prototype.trim()`
+        // happens to treat U+FEFF as whitespace and the default
+        // `TextDecoder("utf-8")` strips a stream-start BOM internally, so
+        // the consumer-visible bug is masked today. Pinning the correct
+        // shape regardless so a future change (`ignoreBOM: true`, or a
+        // line that doesn't run through `.trim()`) doesn't reintroduce it.
+        if (!bomStripped && buffer.length > 0) {
+            bomStripped = true;
+            // Defense-in-depth dead path: in Node 18+ / browsers,
+            // `TextDecoder("utf-8")` defaults to `ignoreBOM: false` and
+            // strips a stream-start BOM internally — by the time the byte
+            // reaches our buffer, the BOM is already gone. The two lines
+            // below are reachable only if a future refactor passes
+            // `{ignoreBOM: true}` to TextDecoder OR processes the buffer
+            // through some path that bypasses TextDecoder's strip. Marked
+            // for v8 coverage to make the intentional defense visible.
+            /* v8 ignore next 3 */
+            if (buffer.charCodeAt(0) === 0xfeff) {
+                buffer = buffer.slice(1);
+            }
+        }
+        // Yield each complete line. We split on `\n` rather than using
+        // String.split to keep the indexing explicit (and to make the
+        // residual-buffer accounting visible).
+        while (true) {
+            const newlineIdx = buffer.indexOf("\n");
+            if (newlineIdx === -1)
+                break;
+            const line = buffer.slice(0, newlineIdx);
+            buffer = buffer.slice(newlineIdx + 1);
+            const trimmed = stripTrailingCR(line).trim();
+            if (trimmed.length === 0)
+                continue; // blank line — skip silently
+            yield parseLine(trimmed);
+        }
+        // Defense in depth: after consuming all complete lines, the residual
+        // buffer holds at most a partial line. If THAT exceeds the cap, the
+        // server emitted an unbounded line (or omitted the delimiter) — bail
+        // before we OOM. Checking after the yield-loop avoids tripping on a
+        // single huge chunk that contains many small complete lines.
+        if (buffer.length > maxLineBytes) {
+            throw new AttestryError(`NDJSON line exceeded maximum buffer size (${maxLineBytes} bytes) — server emitted an unbounded line or omitted the line delimiter`);
+        }
+    }
+}
+/**
+ * Convenience wrapper around `parseNDJSON` that accepts a `Response`,
+ * derives the reader, and ALWAYS calls `reader.cancel()` in a `finally`
+ * block — including when a caller breaks out of the for-await loop
+ * early. Without this, an early `break` leaks the underlying connection.
+ *
+ * Resources should call this rather than `parseNDJSON` directly.
+ *
+ * Symmetric to `parseSSEResponse`.
+ */
+export async function* parseNDJSONResponse(response, options = {}) {
+    if (response.body === null) {
+        // 204 No Content / empty body — iterator ends with zero frames.
+        // (Throwing would be over-strict; the server may legitimately close
+        // before any data — symmetric to parseSSEResponse.)
+        return;
+    }
+    const reader = response.body.getReader();
+    try {
+        yield* parseNDJSON(reader, options);
+    }
+    finally {
+        // Release the lock + signal cancellation upstream. Wrapped in
+        // try/catch because cancel() on an already-closed reader rejects.
+        try {
+            await reader.cancel();
+        }
+        catch {
+            // Already canceled / closed — nothing to do.
+        }
+    }
+}
+// ─── Internals ──────────────────────────────────────────────────────────────
+/**
+ * Trim a single trailing `\r` (CR). Defensive: NDJSON spec mandates LF
+ * only, but a Windows-tooling artifact could leave a CR before the LF.
+ * Trimming exactly one CR keeps the parser permissive without treating
+ * CR alone as a line separator.
+ */
+function stripTrailingCR(s) {
+    return s.length > 0 && s.charCodeAt(s.length - 1) === 0x0d ? s.slice(0, -1) : s;
+}
+/**
+ * True if `err` is an AbortError-shaped exception (DOMException or
+ * Error with `name === "AbortError"`). Both browsers and Node 18+
+ * produce this shape when `fetch` / `reader.read()` is aborted via
+ * `AbortController.abort()`. Type-narrowing on DOMException alone is
+ * too broad (it includes other DOM error types); check by name. Same
+ * helper signature as `isAbortError` in `resources/decisions.ts`.
+ */
+function isAbortErrorShape(err) {
+    return (err !== null &&
+        typeof err === "object" &&
+        "name" in err &&
+        err.name === "AbortError");
+}
+/**
+ * Parse one trimmed line as JSON. Throws `AttestryError` (with the
+ * underlying error as `cause`) if the payload isn't valid JSON.
+ */
+function parseLine(line) {
+    try {
+        return JSON.parse(line);
+    }
+    catch (err) {
+        throw new AttestryError(`NDJSON line was not valid JSON: ${
+        // JSON.parse always throws SyntaxError (an Error subclass), so
+        // the String(err) branch is unreachable. Defense-in-depth.
+        /* v8 ignore next */
+        err instanceof Error ? err.message : String(err)}`, { cause: err });
+    }
+}
+// Test-only handles for direct pinning of internals.
+export const __test__ = {
+    DEFAULT_MAX_LINE_BYTES,
+    parseLine,
+    stripTrailingCR,
+};
+//# sourceMappingURL=ndjson-parser.js.map

package/dist/ndjson-parser.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ndjson-parser.js","sourceRoot":"","sources":["../src/ndjson-parser.ts"],"names":[],"mappings":"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"}