@ricsam/isolate-fetch 0.0.1 → 0.1.1

package/CHANGELOG.md

@@ -0,0 +1,9 @@
+# @ricsam/isolate-fetch
+
+## 0.1.1
+
+### Patch Changes
+
+- initial release
+- Updated dependencies
+  - @ricsam/isolate-core@0.1.1

package/package.json

@@ -1,10 +1,30 @@
 {
   "name": "@ricsam/isolate-fetch",
-  "version": "0.0.1",
-  "description": "OIDC trusted publishing setup package for @ricsam/isolate-fetch",
-  "keywords": [
-    "oidc",
-    "trusted-publishing",
-    "setup"
-  ]
+  "version": "0.1.1",
+  "type": "module",
+  "main": "./src/index.ts",
+  "types": "./src/index.ts",
+  "exports": {
+    ".": {
+      "import": "./src/index.ts",
+      "types": "./src/index.ts"
+    }
+  },
+  "scripts": {
+    "build": "tsc",
+    "test": "node --test --experimental-strip-types 'src/**/*.test.ts'",
+    "typecheck": "tsc --noEmit"
+  },
+  "dependencies": {
+    "@ricsam/isolate-core": "*",
+    "isolated-vm": "^6"
+  },
+  "devDependencies": {
+    "@ricsam/isolate-test-utils": "*",
+    "@types/node": "^24",
+    "typescript": "^5"
+  },
+  "peerDependencies": {
+    "isolated-vm": "^6"
+  }
 }

package/src/debug-delayed.test.ts

@@ -0,0 +1,89 @@
+import { test, describe, beforeEach, afterEach, it } from "node:test";
+import assert from "node:assert";
+import ivm from "isolated-vm";
+import {
+  setupFetch,
+  clearAllInstanceState,
+  type FetchHandle,
+} from "./index.ts";
+import { setupTimers, type TimersHandle } from "@ricsam/isolate-timers";
+import { setupConsole } from "@ricsam/isolate-console";
+import { clearStreamRegistryForContext } from "./stream-state.ts";
+
+describe("Debug Delayed Streaming", () => {
+  it("delayed streaming response with setTimeout", { timeout: 10000 }, async () => {
+    const isolate = new ivm.Isolate();
+    const context = await isolate.createContext();
+    clearAllInstanceState();
+
+    const logs: string[] = [];
+    await setupConsole(context, {
+      onLog: (level, ...args) => {
+        logs.push(`[${level}] ${args.join(' ')}`);
+        console.log(`[ISOLATE] ${args.join(' ')}`);
+      }
+    });
+
+    const timersHandle = await setupTimers(context);
+    const fetchHandle = await setupFetch(context);
+
+    try {
+      context.evalSync(`
+        console.log('Setting up serve');
+        serve({
+          async fetch(request) {
+            console.log('Fetch handler called');
+            let count = 0;
+            const stream = new ReadableStream({
+              async pull(controller) {
+                console.log('pull() called, count =', count);
+                if (count < 3) {
+                  console.log('Starting setTimeout');
+                  await new Promise(r => setTimeout(r, 10));
+                  console.log('setTimeout resolved');
+                  const data = "delayed" + count;
+                  console.log('Enqueuing:', data);
+                  controller.enqueue(new TextEncoder().encode(data));
+                  count++;
+                  console.log('Enqueued, returning');
+                } else {
+                  console.log('Closing stream');
+                  controller.close();
+                }
+              }
+            });
+            console.log('Creating Response');
+            const response = new Response(stream);
+            console.log('Response created, returning');
+            return response;
+          }
+        });
+        console.log('Serve registered');
+      `);
+
+      console.log('Calling dispatchRequest');
+      const response = await fetchHandle.dispatchRequest(
+        new Request("http://test/"),
+        {
+          tick: async () => {
+            // Advance virtual time by 50ms each tick to process timers
+            await timersHandle.tick(50);
+          }
+        }
+      );
+
+      console.log('Got response, status:', response.status);
+      console.log('Calling response.text()');
+
+      const text = await response.text();
+      console.log('Got text:', text);
+      assert.strictEqual(text, "delayed0delayed1delayed2");
+    } finally {
+      fetchHandle.dispose();
+      timersHandle.dispose();
+      clearStreamRegistryForContext(context);
+      context.release();
+      isolate.dispose();
+    }
+  });
+});

package/src/debug-streaming.test.ts

@@ -0,0 +1,81 @@
+import { test, describe, beforeEach, afterEach, it } from "node:test";
+import assert from "node:assert";
+import ivm from "isolated-vm";
+import {
+  setupFetch,
+  clearAllInstanceState,
+  type FetchHandle,
+} from "./index.ts";
+import { setupTimers, type TimersHandle } from "@ricsam/isolate-timers";
+import { setupConsole } from "@ricsam/isolate-console";
+import { clearStreamRegistryForContext } from "./stream-state.ts";
+
+describe("Debug Streaming", () => {
+  it("debug pull-based stream", { timeout: 5000 }, async () => {
+    const isolate = new ivm.Isolate();
+    const context = await isolate.createContext();
+    clearAllInstanceState();
+
+    const logs: string[] = [];
+    await setupConsole(context, {
+      onLog: (level, ...args) => {
+        logs.push(`[${level}] ${args.join(' ')}`);
+        console.log(`[ISOLATE] ${args.join(' ')}`);
+      }
+    });
+
+    const timersHandle = await setupTimers(context);
+    const fetchHandle = await setupFetch(context);
+
+    try {
+      context.evalSync(`
+        console.log('Setting up serve');
+        serve({
+          async fetch(request) {
+            console.log('Fetch handler called');
+            let count = 0;
+            const stream = new ReadableStream({
+              pull(controller) {
+                console.log('pull() called, count =', count);
+                if (count < 3) {
+                  const data = "chunk" + count;
+                  console.log('Enqueuing:', data);
+                  controller.enqueue(new TextEncoder().encode(data));
+                  count++;
+                } else {
+                  console.log('Closing stream');
+                  controller.close();
+                }
+              }
+            });
+            console.log('Creating Response');
+            const response = new Response(stream);
+            console.log('Response created, returning');
+            return response;
+          }
+        });
+        console.log('Serve registered');
+      `);
+
+      console.log('Calling dispatchRequest');
+      const response = await fetchHandle.dispatchRequest(
+        new Request("http://test/"),
+        { tick: () => timersHandle.tick() }
+      );
+
+      console.log('Got response, status:', response.status);
+      console.log('Response body:', response.body);
+      console.log('Calling response.text()');
+
+      const text = await response.text();
+      console.log('Got text:', text);
+      assert.strictEqual(text, "chunk0chunk1chunk2");
+    } finally {
+      fetchHandle.dispose();
+      timersHandle.dispose();
+      clearStreamRegistryForContext(context);
+      context.release();
+      isolate.dispose();
+    }
+  });
+});

package/src/download-streaming-simple.test.ts

@@ -0,0 +1,167 @@
+import { test, describe, beforeEach, afterEach, it } from "node:test";
+import assert from "node:assert";
+import ivm from "isolated-vm";
+import {
+  setupFetch,
+  clearAllInstanceState,
+  type FetchHandle,
+} from "./index.ts";
+import { setupTimers, type TimersHandle } from "@ricsam/isolate-timers";
+import { clearStreamRegistryForContext } from "./stream-state.ts";
+
+describe("Download Streaming Simple", () => {
+  it("Test 1: sync start", async () => {
+    const isolate = new ivm.Isolate();
+    const context = await isolate.createContext();
+    clearAllInstanceState();
+
+    const timersHandle = await setupTimers(context);
+    const fetchHandle = await setupFetch(context);
+
+    try {
+      context.evalSync(`
+        serve({
+          async fetch(request) {
+            const stream = new ReadableStream({
+              start(controller) {
+                controller.enqueue(new TextEncoder().encode("chunk1"));
+                controller.enqueue(new TextEncoder().encode("chunk2"));
+                controller.close();
+              }
+            });
+            return new Response(stream);
+          }
+        });
+      `);
+
+      const response = await fetchHandle.dispatchRequest(
+        new Request("http://test/"),
+        { tick: () => timersHandle.tick() }
+      );
+
+      const text = await response.text();
+      assert.strictEqual(text, "chunk1chunk2");
+    } finally {
+      fetchHandle.dispose();
+      timersHandle.dispose();
+      clearStreamRegistryForContext(context);
+      context.release();
+      isolate.dispose();
+    }
+  });
+
+  it("Test 2: non-streaming", async () => {
+    const isolate = new ivm.Isolate();
+    const context = await isolate.createContext();
+    clearAllInstanceState();
+
+    const timersHandle = await setupTimers(context);
+    const fetchHandle = await setupFetch(context);
+
+    try {
+      context.evalSync(`
+        serve({
+          async fetch(request) {
+            return new Response("buffered");
+          }
+        });
+      `);
+
+      const response = await fetchHandle.dispatchRequest(
+        new Request("http://test/")
+      );
+
+      const text = await response.text();
+      assert.strictEqual(text, "buffered");
+    } finally {
+      fetchHandle.dispose();
+      timersHandle.dispose();
+      clearStreamRegistryForContext(context);
+      context.release();
+      isolate.dispose();
+    }
+  });
+
+  it("Test 3: sync start again", async () => {
+    const isolate = new ivm.Isolate();
+    const context = await isolate.createContext();
+    clearAllInstanceState();
+
+    const timersHandle = await setupTimers(context);
+    const fetchHandle = await setupFetch(context);
+
+    try {
+      context.evalSync(`
+        serve({
+          async fetch(request) {
+            const stream = new ReadableStream({
+              start(controller) {
+                controller.enqueue(new TextEncoder().encode("test"));
+                controller.close();
+              }
+            });
+            return new Response(stream);
+          }
+        });
+      `);
+
+      const response = await fetchHandle.dispatchRequest(
+        new Request("http://test/"),
+        { tick: () => timersHandle.tick() }
+      );
+
+      const text = await response.text();
+      assert.strictEqual(text, "test");
+    } finally {
+      fetchHandle.dispose();
+      timersHandle.dispose();
+      clearStreamRegistryForContext(context);
+      context.release();
+      isolate.dispose();
+    }
+  });
+
+  it("Test 4: pull-based stream", { timeout: 10000 }, async () => {
+    const isolate = new ivm.Isolate();
+    const context = await isolate.createContext();
+    clearAllInstanceState();
+
+    const timersHandle = await setupTimers(context);
+    const fetchHandle = await setupFetch(context);
+
+    try {
+      context.evalSync(`
+        serve({
+          async fetch(request) {
+            let count = 0;
+            const stream = new ReadableStream({
+              pull(controller) {
+                if (count < 3) {
+                  controller.enqueue(new TextEncoder().encode("chunk" + count));
+                  count++;
+                } else {
+                  controller.close();
+                }
+              }
+            });
+            return new Response(stream);
+          }
+        });
+      `);
+
+      const response = await fetchHandle.dispatchRequest(
+        new Request("http://test/"),
+        { tick: () => timersHandle.tick() }
+      );
+
+      const text = await response.text();
+      assert.strictEqual(text, "chunk0chunk1chunk2");
+    } finally {
+      fetchHandle.dispose();
+      timersHandle.dispose();
+      clearStreamRegistryForContext(context);
+      context.release();
+      isolate.dispose();
+    }
+  });
+});

package/src/download-streaming.test.ts

@@ -0,0 +1,286 @@
+import { test, describe, beforeEach, afterEach, it } from "node:test";
+import assert from "node:assert";
+import ivm from "isolated-vm";
+import {
+  setupFetch,
+  clearAllInstanceState,
+  type FetchHandle,
+} from "./index.ts";
+import { setupTimers, type TimersHandle } from "@ricsam/isolate-timers";
+import { clearStreamRegistryForContext } from "./stream-state.ts";
+
+describe("Download Streaming", () => {
+  let isolate: ivm.Isolate;
+  let context: ivm.Context;
+  let fetchHandle: FetchHandle;
+  let timersHandle: TimersHandle;
+
+  beforeEach(async () => {
+    isolate = new ivm.Isolate();
+    context = await isolate.createContext();
+    clearAllInstanceState();
+
+    // Setup timers first (needed for setTimeout in stream pump)
+    timersHandle = await setupTimers(context);
+
+    // Then setup fetch
+    fetchHandle = await setupFetch(context);
+  });
+
+  afterEach(async () => {
+    fetchHandle.dispose();
+    timersHandle.dispose();
+    clearStreamRegistryForContext(context);
+    context.release();
+    isolate.dispose();
+  });
+
+  it("Response with ReadableStream body (sync start) streams to native", async () => {
+    context.evalSync(`
+      serve({
+        async fetch(request) {
+          const stream = new ReadableStream({
+            start(controller) {
+              controller.enqueue(new TextEncoder().encode("chunk1"));
+              controller.enqueue(new TextEncoder().encode("chunk2"));
+              controller.close();
+            }
+          });
+          return new Response(stream);
+        }
+      });
+    `);
+
+    const response = await fetchHandle.dispatchRequest(
+      new Request("http://test/"),
+      { tick: () => timersHandle.tick() }
+    );
+
+    const text = await response.text();
+    assert.strictEqual(text, "chunk1chunk2");
+  });
+
+  it("Response with ReadableStream body (pull-based) streams to native", async () => {
+    context.evalSync(`
+      serve({
+        async fetch(request) {
+          let count = 0;
+          const stream = new ReadableStream({
+            pull(controller) {
+              if (count < 3) {
+                controller.enqueue(new TextEncoder().encode("chunk" + count));
+                count++;
+              } else {
+                controller.close();
+              }
+            }
+          });
+          return new Response(stream);
+        }
+      });
+    `);
+
+    const response = await fetchHandle.dispatchRequest(
+      new Request("http://test/"),
+      { tick: () => timersHandle.tick() }
+    );
+
+    const text = await response.text();
+    assert.strictEqual(text, "chunk0chunk1chunk2");
+  });
+
+  it("Response with HostBackedReadableStream body streams to native", async () => {
+    context.evalSync(`
+      serve({
+        async fetch(request) {
+          // Create a HostBackedReadableStream manually
+          const stream = new HostBackedReadableStream();
+          const streamId = stream._getStreamId();
+
+          // Push data directly to the stream
+          __Stream_push(streamId, Array.from(new TextEncoder().encode("host")));
+          __Stream_push(streamId, Array.from(new TextEncoder().encode("backed")));
+          __Stream_close(streamId);
+
+          return new Response(stream);
+        }
+      });
+    `);
+
+    const response = await fetchHandle.dispatchRequest(
+      new Request("http://test/"),
+      { tick: () => timersHandle.tick() }
+    );
+
+    const text = await response.text();
+    assert.strictEqual(text, "hostbacked");
+  });
+
+  it("delayed streaming response with setTimeout works", async () => {
+    context.evalSync(`
+      serve({
+        async fetch(request) {
+          let count = 0;
+          const stream = new ReadableStream({
+            async pull(controller) {
+              if (count < 3) {
+                await new Promise(r => setTimeout(r, 10));
+                controller.enqueue(new TextEncoder().encode("delayed" + count));
+                count++;
+              } else {
+                controller.close();
+              }
+            }
+          });
+          return new Response(stream);
+        }
+      });
+    `);
+
+    const response = await fetchHandle.dispatchRequest(
+      new Request("http://test/"),
+      { tick: () => timersHandle.tick(50) }  // Advance 50ms to process timers
+    );
+
+    const text = await response.text();
+    assert.strictEqual(text, "delayed0delayed1delayed2");
+  });
+
+  it("streaming response preserves headers", async () => {
+    context.evalSync(`
+      serve({
+        async fetch(request) {
+          const stream = new ReadableStream({
+            start(controller) {
+              controller.enqueue(new TextEncoder().encode("test"));
+              controller.close();
+            }
+          });
+          return new Response(stream, {
+            status: 201,
+            statusText: "Created",
+            headers: {
+              "Content-Type": "text/plain",
+              "X-Custom": "value"
+            }
+          });
+        }
+      });
+    `);
+
+    const response = await fetchHandle.dispatchRequest(
+      new Request("http://test/"),
+      { tick: () => timersHandle.tick() }
+    );
+
+    assert.strictEqual(response.status, 201);
+    assert.strictEqual(response.headers.get("Content-Type"), "text/plain");
+    assert.strictEqual(response.headers.get("X-Custom"), "value");
+    assert.strictEqual(await response.text(), "test");
+  });
+
+  it("stream error propagates to native consumer", async () => {
+    context.evalSync(`
+      serve({
+        async fetch(request) {
+          let count = 0;
+          const stream = new ReadableStream({
+            pull(controller) {
+              if (count < 1) {
+                controller.enqueue(new TextEncoder().encode("ok"));
+                count++;
+              } else {
+                controller.error(new Error("Stream failed"));
+              }
+            }
+          });
+          return new Response(stream);
+        }
+      });
+    `);
+
+    const response = await fetchHandle.dispatchRequest(
+      new Request("http://test/"),
+      { tick: () => timersHandle.tick() }
+    );
+
+    // The first chunk should be readable
+    const reader = response.body!.getReader();
+    const firstRead = await reader.read();
+    assert.strictEqual(firstRead.done, false);
+    assert.deepStrictEqual(
+      new TextDecoder().decode(firstRead.value),
+      "ok"
+    );
+
+    // Second read should throw
+    await assert.rejects(reader.read());
+  });
+
+  it("multiple chunks read sequentially", async () => {
+    context.evalSync(`
+      serve({
+        async fetch(request) {
+          const stream = new ReadableStream({
+            start(controller) {
+              controller.enqueue(new TextEncoder().encode("a"));
+              controller.enqueue(new TextEncoder().encode("b"));
+              controller.enqueue(new TextEncoder().encode("c"));
+              controller.close();
+            }
+          });
+          return new Response(stream);
+        }
+      });
+    `);
+
+    const response = await fetchHandle.dispatchRequest(
+      new Request("http://test/"),
+      { tick: () => timersHandle.tick() }
+    );
+
+    const reader = response.body!.getReader();
+    const chunks: string[] = [];
+
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      chunks.push(new TextDecoder().decode(value));
+    }
+
+    assert.deepStrictEqual(chunks, ["a", "b", "c"]);
+  });
+
+  it("non-streaming response still works", async () => {
+    context.evalSync(`
+      serve({
+        async fetch(request) {
+          return new Response("buffered response");
+        }
+      });
+    `);
+
+    const response = await fetchHandle.dispatchRequest(
+      new Request("http://test/")
+    );
+
+    assert.strictEqual(await response.text(), "buffered response");
+  });
+
+  it("Response.json() still works", async () => {
+    context.evalSync(`
+      serve({
+        async fetch(request) {
+          return Response.json({ hello: "world" });
+        }
+      });
+    `);
+
+    const response = await fetchHandle.dispatchRequest(
+      new Request("http://test/")
+    );
+
+    const data = await response.json();
+    assert.deepStrictEqual(data, { hello: "world" });
+  });
+});