a2a-exposed 0.4.1 → 0.6.0

package/worker/test/d1.ts

@@ -1,9 +1,21 @@
 // Minimal D1 stand-in over node:sqlite (in-memory), with the repo's migrations applied: lets tests drive the real
 // Worker fetch handler. Covers what the Worker uses: prepare().bind().first()/all()/run(), RETURNING, and batch().
+//
+// STORAGE_BACKEND=d1|do runs the same calls against workerd (Miniflare): d1 is a real D1 binding, do is a SQLite
+// Durable Object behind src/storage.ts. The Worker code stays in this process; only storage is remote. Calls are
+// synchronous via a worker thread and Atomics, so `s.DB.db.prepare(...).get()` keeps working. Unset (the default,
+// and what migrations.test.ts's d1On and the CLI tests use) stays on node:sqlite.
 import { DatabaseSync } from "node:sqlite";
 import fs from "node:fs";
+import path from "node:path";
+import { Worker, MessageChannel, receiveMessageOnPort } from "node:worker_threads";
+import { createRequire } from "node:module";
+import { fileURLToPath } from "node:url";
+
+const BACKEND = process.env.STORAGE_BACKEND || "node";
 
 export function d1(migrationsDir: URL) {
+	if (BACKEND !== "node") return remote(migrationsDir);
 	const db = new DatabaseSync(":memory:");
 	for (const f of fs.readdirSync(migrationsDir).filter((n) => n.endsWith(".sql")).sort())
 		db.exec(fs.readFileSync(new URL(f, migrationsDir), "utf8"));
@@ -13,6 +25,8 @@ export function d1(migrationsDir: URL) {
 /** The same D1 stand-in over an existing node:sqlite database (e.g. one whose schema a test built step by step). */
 export function d1On(db: DatabaseSync) {
 	const stmt = (sql: string, args: unknown[] = []): any => ({
+		__sql: sql,
+		__args: args,
 		bind: (...a: unknown[]) => stmt(sql, a),
 		first: async (col?: string) => {
 			const r: any = db.prepare(sql).get(...(args as any[]));
@@ -29,10 +43,140 @@ export function d1On(db: DatabaseSync) {
 	return {
 		db,
 		prepare: (sql: string) => stmt(sql),
+		// One transaction, matching D1: a batch rolls back together, and SELECT results are returned.
+		// Statements are run from their SQL so a caller that only implements batch (no per-table all()) still works.
 		batch: async (stmts: any[]) => {
 			db.exec("BEGIN");
-			try { const out = []; for (const s of stmts) out.push(await s.run()); db.exec("COMMIT"); return out; }
-			catch (e) { db.exec("ROLLBACK"); throw e; }
+			try {
+				const out = [];
+				for (const s of stmts) {
+					const sql = s.__sql as string | undefined;
+					const args = (s.__args ?? []) as any[];
+					if (!sql) { out.push(await s.run()); continue; }
+					if (/^\s*(select|pragma|with)\b/i.test(sql)) {
+						const rows = db.prepare(sql).all(...args).map((r: any) => ({ ...r }));
+						out.push({ results: rows, meta: { changes: 0 } });
+					} else if (/\breturning\b/i.test(sql)) {
+						const rows = db.prepare(sql).all(...args).map((r: any) => ({ ...r }));
+						out.push({ results: rows, meta: { changes: rows.length } });
+					} else {
+						const r = db.prepare(sql).run(...args);
+						out.push({ results: [], meta: { changes: Number(r.changes) } });
+					}
+				}
+				db.exec("COMMIT");
+				return out;
+			} catch (e) {
+				try { db.exec("ROLLBACK"); } catch { /* the statement failed before BEGIN committed */ }
+				throw e;
+			}
 		},
 	};
 }
+
+const POOL = 8;
+let bridge: { port: import("node:worker_threads").MessagePort; flag: Int32Array } | null = null;
+let next = 0;
+export const remoteStats = { calls: 0, ms: 0 };
+
+async function bundleHarness(): Promise<string> {
+	const require = createRequire(new URL("../package.json", import.meta.url));
+	const { build } = require("esbuild") as typeof import("esbuild");
+	const built = await build({
+		entryPoints: [fileURLToPath(new URL("./harness-worker.ts", import.meta.url))],
+		bundle: true,
+		format: "esm",
+		write: false,
+		platform: "neutral",
+		external: ["cloudflare:*"],
+		target: "es2022",
+		logLevel: "silent",
+		plugins: [{
+			name: "sql-raw",
+			setup(b) {
+				b.onResolve({ filter: /\.sql\?raw$/ }, (args) => ({
+					path: path.resolve(args.resolveDir, args.path.replace(/\?raw$/, "")),
+					namespace: "sql-raw",
+				}));
+				b.onLoad({ filter: /.*/, namespace: "sql-raw" }, (args) => ({
+					contents: `export default ${JSON.stringify(fs.readFileSync(args.path, "utf8"))};`,
+					loader: "js",
+				}));
+			},
+		}],
+	});
+	const file = built.outputFiles?.[0];
+	if (!file) throw new Error("storage harness bundle was empty");
+	return file.text;
+}
+
+let harnessScript: string | null = null;
+if (BACKEND !== "node") harnessScript = await bundleHarness();
+
+function bridgeCall(reqPath: string, body: unknown): any {
+	if (!bridge) {
+		const script = harnessScript;
+		if (!script) throw new Error("storage harness was not bundled");
+		const { port1, port2 } = new MessageChannel();
+		const flag = new Int32Array(new SharedArrayBuffer(4));
+		const w = new Worker(new URL("./bridge-thread.mjs", import.meta.url), {
+			workerData: { port: port2, flag: flag.buffer, script, pool: POOL },
+			transferList: [port2],
+		});
+		w.on("message", (m) => { if (m?.error) console.error(m.error); });
+		bridge = { port: port1, flag };
+		if (Atomics.wait(flag, 0, 0, 120_000) === "timed-out") throw new Error("storage bridge did not start");
+		const ready = receiveMessageOnPort(port1)?.message;
+		if (ready && ready.ready === false) throw new Error(ready.error || "storage bridge did not start");
+		// Listening for `message` refs the worker. Drop that ref once Miniflare is up so the test
+		// process can exit; workerd stays up for later calls and dies with the process.
+		w.unref();
+		port1.unref();
+	}
+	const t0 = performance.now();
+	Atomics.store(bridge.flag, 0, 0);
+	bridge.port.postMessage({ path: reqPath, body });
+	if (Atomics.wait(bridge.flag, 0, 0, 30_000) === "timed-out") throw new Error("storage bridge timeout");
+	const m = receiveMessageOnPort(bridge.port)!.message;
+	remoteStats.calls++;
+	remoteStats.ms += performance.now() - t0;
+	if (!m.ok) throw new Error(m.error);
+	return m.value;
+}
+
+function remote(migrationsDir: URL) {
+	let reqPath: string;
+	if (BACKEND === "d1") {
+		reqPath = `/DB${next++ % POOL}`;
+		const files = fs.readdirSync(migrationsDir).filter((n) => n.endsWith(".sql")).sort()
+			.map((name) => ({ name, sql: fs.readFileSync(new URL(name, migrationsDir), "utf8") }));
+		bridgeCall(reqPath, { op: "reset", files });
+	} else if (BACKEND === "do") {
+		reqPath = `/do/t-${process.pid}-${next++}-${Math.random().toString(36).slice(2)}`;
+	} else throw new Error("STORAGE_BACKEND must be node, d1 or do");
+	const call = (body: unknown) => bridgeCall(reqPath, body);
+	const stmt = (sql: string, args: unknown[] = []): any => ({
+		__sql: sql, __args: args,
+		bind: (...a: unknown[]) => stmt(sql, a),
+		first: async (col?: string) => call({ op: "first", sql, args, col }),
+		all: async () => call({ op: "all", sql, args }),
+		run: async () => call({ op: "run", sql, args }),
+		raw: async () => call({ op: "raw", sql, args }),
+	});
+	const db = {
+		prepare: (sql: string) => ({
+			get: (...args: unknown[]) => call({ op: "first", sql, args }) ?? undefined,
+			all: (...args: unknown[]) => call({ op: "all", sql, args }).results,
+			run: (...args: unknown[]) => { const r = call({ op: "run", sql, args }); return { changes: r.meta.changes }; },
+		}),
+	};
+	return {
+		db, path: reqPath,
+		prepare: (sql: string) => stmt(sql),
+		batch: async (stmts: any[]) => call({ op: "batch", stmts: stmts.map((s) => ({ sql: s.__sql, args: s.__args })) }),
+	};
+}
+
+if (BACKEND !== "node") process.on("exit", () => {
+	if (remoteStats.calls) process.stdout.write(`# storage[${BACKEND}] ${remoteStats.calls} ops, avg ${(remoteStats.ms / remoteStats.calls).toFixed(3)} ms/op (incl. thread+HTTP bridge)\n`);
+});

package/worker/test/directory.test.ts

@@ -0,0 +1,90 @@
+// Name directory: host parsing and the 60s isolate cache. Run: npm test
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { clearDirectoryCache, DIRECTORY_MAX, directoryKey, lookupDirectory, parseDirectoryEntry, pinDirectoryRegion, TENANT_NAME, tenantNameFromHost, tenantRegion } from "../src/directory.ts";
+
+test("tenant names are 4–32 characters and one label under the domain", () => {
+	assert.equal(TENANT_NAME.test("abcd"), true);
+	assert.equal(TENANT_NAME.test("abc"), false);
+	assert.equal(TENANT_NAME.test("a".repeat(32)), true);
+	assert.equal(TENANT_NAME.test("a".repeat(33)), false);
+	assert.equal(TENANT_NAME.test("-abcd"), false);
+	assert.equal(TENANT_NAME.test("abcd-"), false);
+	assert.equal(tenantNameFromHost("abcd.example.com", "example.com"), "abcd");
+	assert.equal(tenantNameFromHost("ABCD.Example.COM", "example.com"), "abcd");
+	assert.equal(tenantNameFromHost("example.com", "example.com"), null);
+	assert.equal(tenantNameFromHost("a.b.example.com", "example.com"), null);
+	assert.equal(tenantNameFromHost("abcd.example.com.evil.example", "example.com"), null);
+	assert.equal(tenantNameFromHost("abcd.example.org", "example.com"), null);
+	assert.equal(tenantNameFromHost("abcd.example.com", ""), null);
+});
+
+test("directory entries need an id and a status; only a stored eu or fedramp selects a jurisdiction", () => {
+	assert.equal(parseDirectoryEntry(null), null);
+	assert.equal(parseDirectoryEntry({ id: "../x", status: "active" }), null);
+	assert.equal(parseDirectoryEntry({ id: "t1", status: "Active" }), null);
+	const ok = parseDirectoryEntry({ id: "t1", status: "active", region: "eu", version: 3 });
+	assert.deepEqual(ok, { id: "t1", status: "active", region: "eu", version: 3 });
+	assert.equal(tenantRegion(ok!), "eu");
+	assert.equal(tenantRegion({ id: "t1", status: "active", region: "default", version: 1 }), "");
+	assert.equal(tenantRegion({ id: "t1", status: "active", region: "", version: 1 }), "");
+});
+
+test("an empty region is pinned once; a later DATA_REGION does not move the tenant", async () => {
+	clearDirectoryCache();
+	const store = new Map<string, string>();
+	const kv = {
+		async put(key: string, value: string) { store.set(key, value); },
+	};
+	const entry = { id: "t1", status: "active", region: "", version: 1 };
+	const pinned = await pinDirectoryRegion(kv, "abcd", entry, "fedramp", 1_000);
+	assert.equal(pinned?.region, "fedramp");
+	assert.equal(JSON.parse(store.get(directoryKey("abcd"))!).region, "fedramp");
+	const again = await pinDirectoryRegion(kv, "abcd", pinned!, "eu", 2_000);
+	assert.equal(again?.region, "fedramp");
+	assert.equal(tenantRegion(again!), "fedramp");
+	const fresh = { id: "t2", status: "active", region: "", version: 1 };
+	const fallback = await pinDirectoryRegion(kv, "efgh", fresh, "", 3_000);
+	assert.equal(fallback?.region, "default");
+	assert.equal(tenantRegion(fallback!), "");
+	const failed = await pinDirectoryRegion({ async put() { throw new Error("kv down"); } }, "ijkl", fresh, "eu", 4_000);
+	assert.equal(failed, null);
+	clearDirectoryCache();
+});
+
+test("lookups are cached for 60s, including unknown names", async () => {
+	clearDirectoryCache();
+	const store = new Map<string, string>();
+	const kv = {
+		async get(key: string, type?: string) {
+			const v = store.get(key);
+			if (v == null) return null;
+			return type === "json" ? JSON.parse(v) : v;
+		},
+	};
+	store.set(directoryKey("abcd"), JSON.stringify({ id: "t1", status: "active", region: "", version: 1 }));
+	assert.equal((await lookupDirectory(kv, "abcd", 1_000))?.id, "t1");
+	store.set(directoryKey("abcd"), JSON.stringify({ id: "t2", status: "suspended", region: "eu", version: 2 }));
+	assert.equal((await lookupDirectory(kv, "abcd", 1_000 + 59_000))?.id, "t1", "still the cached row");
+	assert.equal((await lookupDirectory(kv, "abcd", 1_000 + 60_000))?.status, "suspended");
+	assert.equal(await lookupDirectory(kv, "nope", 0), null);
+	store.set(directoryKey("nope"), JSON.stringify({ id: "t9", status: "active", region: "", version: 1 }));
+	assert.equal(await lookupDirectory(kv, "nope", 30_000), null, "a miss stays cached");
+	assert.equal((await lookupDirectory(kv, "nope", 60_000))?.id, "t9");
+	clearDirectoryCache();
+});
+
+test("the directory cache evicts the oldest name once it is full", async () => {
+	clearDirectoryCache();
+	let gets = 0;
+	const kv = { async get() { gets++; return null; } };
+	for (let i = 0; i < DIRECTORY_MAX; i++) await lookupDirectory(kv, "k" + i, 1);
+	assert.equal(gets, DIRECTORY_MAX);
+	await lookupDirectory(kv, "overflow", 1);
+	assert.equal(gets, DIRECTORY_MAX + 1);
+	await lookupDirectory(kv, "k0", 1);
+	assert.equal(gets, DIRECTORY_MAX + 2, "the oldest miss was evicted");
+	await lookupDirectory(kv, "overflow", 1);
+	assert.equal(gets, DIRECTORY_MAX + 2, "a name just stored is still cached");
+	clearDirectoryCache();
+});