@cosmicdrift/kumiko-testing 0.381.0 → 0.383.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cosmicdrift/kumiko-testing",
-  "version": "0.381.0",
+  "version": "0.383.0",
   "description": "Test template for Kumiko apps: per-flow seedTenant, app test stack, canonical test preloads, bunfig generator and integration runner.",
   "license": "BUSL-1.1",
   "author": "Marc Frost <marc@cosmicdriftgamestudio.com>",
@@ -99,9 +99,9 @@
     "kumiko-testing": "./bin/kumiko-testing.ts"
   },
   "dependencies": {
-    "@cosmicdrift/kumiko-framework": "0.381.0",
-    "@cosmicdrift/kumiko-guards": "0.381.0",
-    "@cosmicdrift/kumiko-types": "0.381.0",
+    "@cosmicdrift/kumiko-framework": "0.383.0",
+    "@cosmicdrift/kumiko-guards": "0.383.0",
+    "@cosmicdrift/kumiko-types": "0.383.0",
     "zod": "^4.4.3"
   },
   "peerDependencies": {
@@ -125,8 +125,8 @@
     }
   },
   "devDependencies": {
-    "@cosmicdrift/kumiko-bundled-features": "0.381.0",
-    "@cosmicdrift/kumiko-dev-server": "0.381.0",
+    "@cosmicdrift/kumiko-bundled-features": "0.383.0",
+    "@cosmicdrift/kumiko-dev-server": "0.383.0",
     "@happy-dom/global-registrator": "^20.11.2",
     "@playwright/test": "^1.62.1",
     "@testing-library/dom": "^10.4.1",

package/src/changes.json

@@ -1,4 +1,10 @@
 [
+  {
+    "version": "0.382.0",
+    "type": "improvement",
+    "title": "withEnv and readSseFrames test helpers",
+    "detail": "withEnv restores process.env after a callback so parallel no-isolate runs do not leak variables; readSseFrames replaces hand-written SSE stream parsers in tests."
+  },
   {
     "version": "0.381.0",
     "type": "improvement",

package/src/helpers/e2e-generator.ts

@@ -431,6 +431,7 @@ function fieldToFixture(name: string, field: FieldDefinition): unknown {
     case "text": {
       if (field.format === "email") return `e2e-${name}@example.com`;
       if (field.format === "url") return "https://example.com";
+      if (field.format === "iban") return "DE89370400440532013000";
       return `e2e ${name}`;
     }
     case "longText":

package/src/helpers/index.ts

@@ -62,8 +62,10 @@ export {
   sharedWidgetEntity,
   sharedWidgetTable,
 } from "./shared-entities.ts";
+export { readSseFrames, type SseFrame } from "./sse-frames.ts";
 export { createTestStoredEvent } from "./stored-event-fixture.ts";
 export { sleep } from "./utils.ts";
 export { waitFor } from "./wait-for.ts";
+export { withEnv } from "./with-env.ts";
 export { withoutAmbientTemporal } from "./without-ambient-temporal.ts";
 export { zipWithEntries } from "./zip-fixture.ts";

package/src/helpers/sse-frames.ts

@@ -0,0 +1,82 @@
+export type SseFrame = {
+  readonly event: string | undefined;
+  readonly data: string;
+  readonly id: string | undefined;
+};
+
+export type ReadSseFramesOptions = {
+  readonly until: (frame: SseFrame, all: readonly SseFrame[]) => boolean;
+  readonly skipPings?: boolean;
+  readonly timeoutMs?: number;
+};
+
+const DEFAULT_TIMEOUT_MS = 5000;
+
+export async function readSseFrames(
+  response: Response,
+  options: ReadSseFramesOptions,
+): Promise<SseFrame[]> {
+  if (response.body === null) {
+    throw new Error("sse response has no body");
+  }
+  const skipPings = options.skipPings ?? true;
+  const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+  const reader = response.body.getReader();
+  const decoder = new TextDecoder();
+  const frames: SseFrame[] = [];
+  let buffer = "";
+  let timer: ReturnType<typeof setTimeout> | undefined;
+  const timedOut = new Promise<never>((_, reject) => {
+    timer = setTimeout(
+      () =>
+        reject(new Error(`sse read timed out after ${timeoutMs}ms: ${frames.length} frames read`)),
+      timeoutMs,
+    );
+  });
+
+  try {
+    for (;;) {
+      const chunk = await Promise.race([reader.read(), timedOut]);
+      if (chunk.done) {
+        throw new Error(`sse stream ended before condition: ${frames.length} frames read`);
+      }
+      buffer += decoder.decode(chunk.value, { stream: true });
+      let separator = buffer.indexOf("\n\n");
+      while (separator !== -1) {
+        const rawFrame = buffer.slice(0, separator);
+        buffer = buffer.slice(separator + 2);
+        const frame = parseFrame(rawFrame);
+        if (frame !== undefined && !(skipPings && frame.event === "ping")) {
+          frames.push(frame);
+          if (options.until(frame, frames)) {
+            return frames;
+          }
+        }
+        separator = buffer.indexOf("\n\n");
+      }
+    }
+  } finally {
+    clearTimeout(timer);
+    await reader.cancel().catch(() => undefined);
+  }
+}
+
+function parseFrame(rawFrame: string): SseFrame | undefined {
+  let event: string | undefined;
+  let id: string | undefined;
+  const dataLines: string[] = [];
+  for (const line of rawFrame.split("\n")) {
+    if (line === "" || line.startsWith(":")) continue;
+    const colon = line.indexOf(":");
+    const field = colon === -1 ? line : line.slice(0, colon);
+    const rawValue = colon === -1 ? "" : line.slice(colon + 1);
+    const value = rawValue.startsWith(" ") ? rawValue.slice(1) : rawValue;
+    if (field === "event") event = value;
+    else if (field === "id") id = value;
+    else if (field === "data") dataLines.push(value);
+  }
+  if (event === undefined && id === undefined && dataLines.length === 0) {
+    return undefined;
+  }
+  return { event, data: dataLines.join("\n"), id };
+}

package/src/helpers/with-env.ts

@@ -0,0 +1,28 @@
+export async function withEnv<T>(
+  overrides: Readonly<Record<string, string | undefined>>,
+  run: () => T | Promise<T>,
+): Promise<T> {
+  const previous = new Map<string, string | undefined>();
+  for (const key of Object.keys(overrides)) {
+    previous.set(key, process.env[key]);
+  }
+  try {
+    for (const [key, value] of Object.entries(overrides)) {
+      applyEnvValue(key, value);
+    }
+    return await run();
+  } finally {
+    for (const [key, value] of previous) {
+      applyEnvValue(key, value);
+    }
+  }
+}
+
+// Assigning undefined would store the string "undefined", so absence must go through delete.
+function applyEnvValue(key: string, value: string | undefined): void {
+  if (value === undefined) {
+    delete process.env[key];
+  } else {
+    process.env[key] = value;
+  }
+}