1tube 0.1.21 → 0.1.23

package/src/backends/deno/worker-entry.ts

@@ -0,0 +1,202 @@
+/**
+ * Worker-side entry point used by the Deno backend.
+ *
+ * One Worker per function. The Worker's lifecycle:
+ *
+ *   host → init     :  { entryUrl, manifest, name }
+ *                      Worker installs the registry stub, dynamically
+ *                      imports the function entry. The entry's top-level
+ *                      `serve()` call lands in our stub, which posts back
+ *                      `{ type: "ready", isPublic, timeoutMs, manifest }`.
+ *
+ *   host → dispatch :  { id, url, method, headers, body, auth }
+ *                      Body comes through as a transferred ReadableStream
+ *                      or null. We rebuild a Request and call the captured
+ *                      handler. The Response (status + headers + body) is
+ *                      posted back, body transferred.
+ *
+ *   host ← error    :  handler threw, or unhandledrejection inside the
+ *                      function code. The host forwards to the supervisor.
+ *
+ * HMR: the host calls `worker.terminate()`. Termination drops Deno's
+ * module cache for everything in the worker's graph, so the next
+ * spawned Worker imports the entry from a clean slate. No filesystem
+ * snapshots, no `?v=` cache-bust hacks.
+ */
+
+/// <reference lib="deno.worker" />
+
+import type { FunctionManifest } from "../../manifest.ts";
+import type { AuthContext } from "../../registry.ts";
+
+interface InitMessage {
+  type: "init";
+  name: string;
+  entryUrl: string;
+  manifest: FunctionManifest;
+}
+
+interface DispatchMessage {
+  type: "dispatch";
+  id: number;
+  url: string;
+  method: string;
+  headers: Array<[string, string]>;
+  body: ReadableStream<Uint8Array> | null;
+  auth: AuthContext | null;
+}
+
+type HostMessage = InitMessage | DispatchMessage;
+
+type Handler = (req: Request, auth?: AuthContext) => Response | Promise<Response>;
+
+interface RegistryStub {
+  register(handler: Handler, opts: { public: boolean; timeoutMs?: number }): void;
+}
+
+interface CapturedHandler {
+  handler: Handler;
+  isPublic: boolean;
+  timeoutMs?: number;
+}
+
+let captured: CapturedHandler | null = null;
+let functionName = "<unknown>";
+let manifest: FunctionManifest | null = null;
+let initDone = false;
+
+const stub: RegistryStub = {
+  register(handler, opts) {
+    if (captured) {
+      // The function called serve() twice. Last write wins, matching the
+      // in-process registry's behaviour. Surface a warning so authors notice
+      // the bug.
+      console.warn(`[1tube] "${functionName}" called serve() twice; using the last handler`);
+    }
+    captured = {
+      handler,
+      isPublic: opts.public,
+      timeoutMs: opts.timeoutMs,
+    };
+  },
+};
+
+(globalThis as { __edgeFunctionRegistry?: RegistryStub }).__edgeFunctionRegistry =
+  stub;
+
+self.addEventListener("unhandledrejection", (e) => {
+  e.preventDefault();
+  const err = (e as PromiseRejectionEvent).reason;
+  postMessage({
+    type: "unhandledrejection",
+    name: functionName,
+    message: err instanceof Error ? err.message : String(err),
+    stack: err instanceof Error ? err.stack : undefined,
+  });
+});
+
+self.addEventListener("error", (e) => {
+  const err = (e as ErrorEvent).error ?? (e as ErrorEvent).message;
+  postMessage({
+    type: "error_event",
+    name: functionName,
+    message: err instanceof Error ? err.message : String(err),
+    stack: err instanceof Error ? err.stack : undefined,
+  });
+});
+
+async function runDispatch(msg: DispatchMessage): Promise<void> {
+  if (!captured) {
+    postMessage({
+      type: "response_error",
+      id: msg.id,
+      message: `Function "${functionName}" did not call serve() before dispatch`,
+    });
+    return;
+  }
+  const headers = new Headers(msg.headers);
+  const init: RequestInit = {
+    method: msg.method,
+    headers,
+  };
+  if (msg.body !== null) {
+    init.body = msg.body;
+    // Half-duplex marker required by Deno when constructing a Request with
+    // a streaming body.
+    (init as unknown as { duplex: "half" }).duplex = "half";
+  }
+  const req = new Request(msg.url, init);
+  let resp: Response;
+  try {
+    resp = await Promise.resolve(
+      captured.isPublic
+        ? captured.handler(req)
+        : captured.handler(req, msg.auth ?? undefined),
+    );
+  } catch (err) {
+    postMessage({
+      type: "response_error",
+      id: msg.id,
+      message: err instanceof Error ? err.message : String(err),
+      stack: err instanceof Error ? err.stack : undefined,
+    });
+    return;
+  }
+  const respHeaders: Array<[string, string]> = [];
+  resp.headers.forEach((v, k) => respHeaders.push([k, v]));
+  const body = resp.body;
+  // We need to send `body` (a ReadableStream) over postMessage. Transfer it
+  // explicitly so the host owns it; that also bypasses structured-clone
+  // limitations on Response objects.
+  postMessage(
+    {
+      type: "response",
+      id: msg.id,
+      status: resp.status,
+      headers: respHeaders,
+      body,
+    },
+    body ? [body as unknown as Transferable] : [],
+  );
+}
+
+self.onmessage = (ev: MessageEvent<HostMessage>) => {
+  const msg = ev.data;
+  if (msg.type === "init") {
+    if (initDone) return;
+    initDone = true;
+    functionName = msg.name;
+    manifest = msg.manifest;
+    void (async () => {
+      try {
+        await import(msg.entryUrl);
+      } catch (err) {
+        postMessage({
+          type: "init_error",
+          message: err instanceof Error ? err.message : String(err),
+          stack: err instanceof Error ? err.stack : undefined,
+        });
+        return;
+      }
+      if (!captured) {
+        postMessage({
+          type: "init_error",
+          message: `Function "${functionName}" loaded without calling serve()`,
+        });
+        return;
+      }
+      postMessage({
+        type: "ready",
+        name: functionName,
+        isPublic: captured.isPublic,
+        timeoutMs: captured.timeoutMs,
+        manifest,
+      });
+    })();
+    return;
+  }
+  if (msg.type === "dispatch") {
+    void runDispatch(msg);
+    return;
+  }
+};

package/src/backends/deno/worker-host.ts

@@ -0,0 +1,466 @@
+/**
+ * Worker-per-function execution host for the Deno backend.
+ *
+ * Each function lives in its own Web Worker. HMR is just
+ *
+ *     handle.terminate(); handle = spawnWorker(...);
+ *
+ * which drops every cached module in that worker's import graph at
+ * once. No filesystem snapshots, no `?v=` cache-bust hacks, no
+ * cross-function state leakage through globals.
+ *
+ * The host owns:
+ *   - one Worker per function, addressable by name
+ *   - in-flight request bookkeeping (correlate by numeric id)
+ *   - per-function dep-graphs (for the hot reloader's affected set)
+ *   - a single Deno.watchFs loop with a debounced flush
+ *
+ * The dispatch path is:
+ *
+ *     gateway → handle.dispatch(req, auth) → postMessage to worker
+ *                                              ↓
+ *                                       worker rebuilds Request
+ *                                              ↓
+ *                                       handler(req, auth?)
+ *                                              ↓
+ *                                       postMessage(response)
+ *                                              ↓
+ *     gateway ← reconstructed Response
+ *
+ * Request and Response bodies are transferred as `ReadableStream`
+ * via the postMessage transfer list, so even multi-megabyte uploads
+ * don't get serialized through structured clone.
+ */
+
+import { join } from "node:path";
+import { pathToFileURL } from "node:url";
+import { defaultManifest, type FunctionManifest, loadManifest } from "../../manifest.ts";
+import type {
+  AuthContext,
+  FunctionRegistry,
+  WorkerFunctionHandle,
+} from "../../registry.ts";
+import type { FunctionSupervisor } from "../../supervisor.ts";
+import { createDepGraph, type DepGraph } from "./dep-graph.ts";
+
+export type DenoWorkerHandle = WorkerFunctionHandle;
+
+export interface DenoWorkerHostOptions {
+  functionsDir: string;
+  registry: FunctionRegistry;
+  supervisor: FunctionSupervisor;
+  /** Debounce window in ms for batched fs change events. Defaults to 200ms. */
+  debounceMs?: number;
+  /** Max concurrent worker spawns at boot/reload. Defaults to 8. */
+  concurrency?: number;
+  /**
+   * Parsed `imports` from the host project's deno.json. Forwarded to the
+   * dep-graph so import-map aliases resolve to the right file URLs. Optional.
+   */
+  importMap?: Readonly<Record<string, string>>;
+  /** Absolute path to the deno.json the import map came from. Required when `importMap` is set. */
+  importMapBase?: string;
+  /** Hook fired on every reload completion (for tests / observability). */
+  onReloaded?: (summary: ReloadSummary) => void;
+}
+
+export interface ReloadSummary {
+  reason: string;
+  reloaded: string[];
+  added: string[];
+  removed: string[];
+  errors: Array<{ name: string; error: string }>;
+  durationMs: number;
+}
+
+interface PendingRequest {
+  resolve: (resp: Response) => void;
+  reject: (err: unknown) => void;
+}
+
+interface InternalHandle extends WorkerFunctionHandle {
+  readonly worker: Worker;
+}
+
+/**
+ * URL of the worker bootstrap module. Captured once so tests can override it
+ * via the option bag if they need to point at a fake.
+ */
+const DEFAULT_WORKER_ENTRY = new URL("./worker-entry.ts", import.meta.url).href;
+
+interface SpawnOpts {
+  name: string;
+  entryUrl: string;
+  manifest: FunctionManifest;
+  workerEntry?: string;
+  /**
+   * Forwarded to FunctionSupervisor when the worker reports an
+   * unhandled rejection. Lets the host attribute orphan rejections
+   * without going through AsyncLocalStorage.
+   */
+  onUnhandledRejection?: (msg: string) => void;
+}
+
+function spawnWorker(opts: SpawnOpts): Promise<InternalHandle> {
+  return new Promise<InternalHandle>((resolve, reject) => {
+    const worker = new Worker(
+      opts.workerEntry ?? DEFAULT_WORKER_ENTRY,
+      { type: "module", name: `1tube-fn-${opts.name}` },
+    );
+
+    const pending = new Map<number, PendingRequest>();
+    let nextId = 1;
+    let booted = false;
+
+    const finishBoot = (handle: InternalHandle) => {
+      booted = true;
+      resolve(handle);
+    };
+
+    const failBoot = (err: Error) => {
+      if (booted) return;
+      try {
+        worker.terminate();
+      } catch { /* */ }
+      reject(err);
+    };
+
+    worker.onerror = (e) => {
+      // Boot-time errors surface here before the worker module finishes
+      // executing (e.g. type errors). After boot, we route per-request
+      // failures through `response_error` instead.
+      const message = e.message || "Worker error";
+      if (!booted) {
+        failBoot(new Error(`Worker for "${opts.name}" failed to start: ${message}`));
+      } else {
+        // Drain any in-flight callers — the worker is dead.
+        for (const p of pending.values()) p.reject(new Error(message));
+        pending.clear();
+      }
+      e.preventDefault?.();
+    };
+
+    worker.onmessage = (ev) => {
+      const m = ev.data as { type: string; [k: string]: unknown };
+      if (m.type === "ready") {
+        const isPublic = Boolean(m.isPublic);
+        const timeoutMs = typeof m.timeoutMs === "number" ? m.timeoutMs : undefined;
+        const manifest = (m.manifest as FunctionManifest) ?? opts.manifest;
+
+        const handle: InternalHandle = {
+          name: opts.name,
+          manifest,
+          isPublic,
+          timeoutMs,
+          worker,
+          async dispatch(req, auth, signal) {
+            if (signal.aborted) {
+              throw new DOMException("Aborted", "AbortError");
+            }
+            const id = nextId++;
+            const headers: Array<[string, string]> = [];
+            req.headers.forEach((v, k) => headers.push([k, v]));
+            const body = req.body;
+            const transferList: Transferable[] = body
+              ? [body as unknown as Transferable]
+              : [];
+            const promise = new Promise<Response>((res, rej) => {
+              pending.set(id, { resolve: res, reject: rej });
+            });
+            const onAbort = () => {
+              const p = pending.get(id);
+              if (p) {
+                pending.delete(id);
+                p.reject(new DOMException("Aborted", "AbortError"));
+              }
+            };
+            signal.addEventListener("abort", onAbort, { once: true });
+            try {
+              worker.postMessage(
+                {
+                  type: "dispatch",
+                  id,
+                  url: req.url,
+                  method: req.method,
+                  headers,
+                  body,
+                  auth,
+                },
+                transferList,
+              );
+            } catch (err) {
+              pending.delete(id);
+              signal.removeEventListener("abort", onAbort);
+              throw err;
+            }
+            try {
+              return await promise;
+            } finally {
+              signal.removeEventListener("abort", onAbort);
+            }
+          },
+          async terminate() {
+            try {
+              worker.terminate();
+            } catch { /* already dead */ }
+            for (const p of pending.values()) {
+              p.reject(new Error(`Worker for "${opts.name}" terminated`));
+            }
+            pending.clear();
+          },
+        };
+        finishBoot(handle);
+        return;
+      }
+
+      if (m.type === "init_error") {
+        failBoot(new Error(String(m.message ?? "init failed")));
+        return;
+      }
+
+      if (m.type === "response") {
+        const id = m.id as number;
+        const p = pending.get(id);
+        if (!p) return;
+        pending.delete(id);
+        const headers = new Headers(m.headers as Array<[string, string]>);
+        const status = m.status as number;
+        const body = (m.body as ReadableStream<Uint8Array> | null) ?? null;
+        // 1xx and 204/205/304 forbid a body; suppress to avoid the
+        // Response constructor throwing.
+        const wantsBody = status >= 200 && status !== 204 && status !== 205 &&
+          status !== 304;
+        p.resolve(new Response(wantsBody ? body : null, { status, headers }));
+        return;
+      }
+
+      if (m.type === "response_error") {
+        const id = m.id as number;
+        const p = pending.get(id);
+        if (!p) return;
+        pending.delete(id);
+        const err = new Error(String(m.message ?? "handler error"));
+        if (m.stack) (err as Error).stack = String(m.stack);
+        p.reject(err);
+        return;
+      }
+
+      if (m.type === "unhandledrejection" || m.type === "error_event") {
+        opts.onUnhandledRejection?.(String(m.message ?? "unknown"));
+        return;
+      }
+    };
+
+    // Kick off init; the worker will reply with `ready` once the
+    // function module's top-level serve() landed in the registry stub.
+    worker.postMessage({
+      type: "init",
+      name: opts.name,
+      entryUrl: opts.entryUrl,
+      manifest: opts.manifest,
+    });
+  });
+}
+
+export interface DenoWorkerHost {
+  start(): Promise<{ loaded: string[]; errors: Array<{ name: string; error: string }> }>;
+  reload(names: ReadonlySet<string> | "all", reason?: string): Promise<ReloadSummary>;
+  stop(): Promise<void>;
+  /** Currently registered function names (loaded + booting). */
+  list(): string[];
+  /** Internal: dep-graph accessor for the hot reloader. */
+  readonly depGraph: DepGraph;
+}
+
+interface DiscoveredCandidate {
+  name: string;
+  entryUrl: string;
+  manifest: FunctionManifest;
+}
+
+async function discoverCandidates(
+  functionsDir: string,
+): Promise<DiscoveredCandidate[]> {
+  const resolved = await Deno.realPath(functionsDir);
+  const out: DiscoveredCandidate[] = [];
+  for await (const entry of Deno.readDir(resolved)) {
+    if (!entry.isDirectory) continue;
+    if (entry.name.startsWith("_") || entry.name.endsWith("_shared")) continue;
+    const indexPath = join(resolved, entry.name, "index.ts");
+    try {
+      await Deno.stat(indexPath);
+    } catch {
+      continue;
+    }
+    const manifest = await loadManifest(resolved, entry.name).catch(() =>
+      defaultManifest()
+    );
+    out.push({
+      name: entry.name,
+      entryUrl: pathToFileURL(indexPath).href,
+      manifest,
+    });
+  }
+  out.sort((a, b) => a.name.localeCompare(b.name));
+  return out;
+}
+
+export function createDenoWorkerHost(opts: DenoWorkerHostOptions): DenoWorkerHost {
+  const handles = new Map<string, InternalHandle>();
+  const depGraph = createDepGraph(
+    opts.importMap && opts.importMapBase
+      ? { importMap: opts.importMap, importMapBase: opts.importMapBase }
+      : undefined,
+  );
+  const concurrency = Math.max(1, opts.concurrency ?? 8);
+
+  async function spawnAndRegister(
+    cand: DiscoveredCandidate,
+  ): Promise<{ handle: InternalHandle } | { error: string }> {
+    try {
+      const handle = await spawnWorker({
+        name: cand.name,
+        entryUrl: cand.entryUrl,
+        manifest: cand.manifest,
+        onUnhandledRejection: (msg) => {
+          // Count orphan rejections against the function so the breaker
+          // can trip on fire-and-forget code that consistently leaks.
+          opts.supervisor.record(cand.name, true);
+          console.error(`[1tube] Unhandled rejection in "${cand.name}": ${msg}`);
+        },
+      });
+      // Update the registry + supervisor in one step so dispatch + admit
+      // see consistent state.
+      const old = handles.get(cand.name);
+      handles.set(cand.name, handle);
+      opts.registry.setWorkerHandle(cand.name, handle);
+      opts.supervisor.setManifest(cand.name, handle.manifest);
+      if (old) {
+        await old.terminate().catch(() => {});
+      }
+      await depGraph.refresh(cand.name, cand.entryUrl);
+      return { handle };
+    } catch (err) {
+      return { error: err instanceof Error ? err.message : String(err) };
+    }
+  }
+
+  async function runBounded<T>(
+    items: T[],
+    fn: (item: T) => Promise<void>,
+  ): Promise<void> {
+    let cursor = 0;
+    const workers = Array.from(
+      { length: Math.min(concurrency, items.length) },
+      async () => {
+        while (true) {
+          const i = cursor++;
+          if (i >= items.length) return;
+          await fn(items[i]);
+        }
+      },
+    );
+    await Promise.all(workers);
+  }
+
+  async function start() {
+    const candidates = await discoverCandidates(opts.functionsDir);
+    const loaded: string[] = [];
+    const errors: Array<{ name: string; error: string }> = [];
+    await runBounded(candidates, async (cand) => {
+      const r = await spawnAndRegister(cand);
+      if ("error" in r) {
+        errors.push({ name: cand.name, error: r.error });
+      } else {
+        loaded.push(cand.name);
+      }
+    });
+    return { loaded, errors };
+  }
+
+  async function reload(
+    names: ReadonlySet<string> | "all",
+    reason = "fs change",
+  ): Promise<ReloadSummary> {
+    const start = performance.now();
+    const candidates = await discoverCandidates(opts.functionsDir);
+    const candByName = new Map(candidates.map((c) => [c.name, c]));
+
+    const targetNames = names === "all"
+      ? new Set(candidates.map((c) => c.name))
+      : new Set(names);
+
+    // Detect deletions: names we currently know about that no longer
+    // have an index.ts on disk.
+    const removed: string[] = [];
+    if (names === "all") {
+      for (const old of handles.keys()) {
+        if (!candByName.has(old)) removed.push(old);
+      }
+    } else {
+      for (const n of targetNames) {
+        if (!candByName.has(n) && handles.has(n)) removed.push(n);
+      }
+    }
+
+    for (const n of removed) {
+      const h = handles.get(n);
+      if (h) await h.terminate().catch(() => {});
+      handles.delete(n);
+      opts.registry.clearWorkerHandle(n);
+      opts.supervisor.forget(n);
+      depGraph.forget(n);
+    }
+
+    const reloaded: string[] = [];
+    const added: string[] = [];
+    const errors: Array<{ name: string; error: string }> = [];
+
+    const toSpawn: DiscoveredCandidate[] = [];
+    for (const n of targetNames) {
+      const c = candByName.get(n);
+      if (!c) continue;
+      toSpawn.push(c);
+    }
+
+    await runBounded(toSpawn, async (cand) => {
+      const wasKnown = handles.has(cand.name);
+      const r = await spawnAndRegister(cand);
+      if ("error" in r) {
+        errors.push({ name: cand.name, error: r.error });
+        // Reset stats for the failing function so the breaker doesn't keep
+        // counting against the dead worker.
+        opts.supervisor.reset(cand.name);
+        return;
+      }
+      if (wasKnown) reloaded.push(cand.name);
+      else added.push(cand.name);
+      opts.supervisor.reset(cand.name);
+    });
+
+    const summary: ReloadSummary = {
+      reason,
+      reloaded: reloaded.sort(),
+      added: added.sort(),
+      removed: removed.sort(),
+      errors,
+      durationMs: performance.now() - start,
+    };
+    opts.onReloaded?.(summary);
+    return summary;
+  }
+
+  async function stop() {
+    const all = [...handles.values()];
+    handles.clear();
+    await Promise.all(all.map((h) => h.terminate().catch(() => {})));
+  }
+
+  return {
+    start,
+    reload,
+    stop,
+    list: () => [...handles.keys()].sort(),
+    depGraph,
+  };
+}