auto-model-router 0.30.3 → 0.32.0

package/test/schema.test.ts

@@ -0,0 +1,123 @@
+/**
+ * The shim's schema against the SQLite bootstrap's.
+ *
+ * `util/schema.ts` declares the FINAL shape of every table; `util/sqlite.ts`
+ * reaches the same shape by replaying nineteen migrations. They are written
+ * twice, so they can drift — and drift here is silent: a missing column makes
+ * the real owner's statements fail only when that code path runs, which is how
+ * a live server refused to start earlier in this port.
+ */
+import { describe, expect, test } from "bun:test";
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+import { migrateStore, STORE_TABLES } from "../src/util/schema.ts";
+import { openSqlDb } from "../src/util/sql.ts";
+import { openDb } from "../src/util/sqlite.ts";
+
+const PG = process.env.AMR_ROUTER_TEST_PG;
+
+/** Column names per table, as the engine reports them. */
+async function columnsOf(url: string): Promise<Map<string, Set<string>>> {
+	const db = openSqlDb(url);
+	const out = new Map<string, Set<string>>();
+	try {
+		for (const table of STORE_TABLES) {
+			const rows =
+				db.dialect === "postgres"
+					? await db.query<{ name: string }>(
+							"SELECT column_name AS name FROM information_schema.columns WHERE table_name = $t",
+							{ t: table },
+						)
+					: await db.query<{ name: string }>(`SELECT name FROM pragma_table_info(${JSON.stringify(table)})`);
+			out.set(table, new Set(rows.map((r) => r.name)));
+		}
+	} finally {
+		await db.close();
+	}
+	return out;
+}
+
+describe("store schema", () => {
+	test("the shim creates every table the sqlite bootstrap does, with the same columns", async () => {
+		const dir = mkdtempSync(join(tmpdir(), "amr-schema-"));
+		try {
+			// The bootstrap's result, after all nineteen migrations.
+			const legacyPath = join(dir, "legacy.db");
+			openDb(legacyPath).close();
+			const legacy = await columnsOf(legacyPath);
+
+			// The shim's result on an empty store.
+			const shimPath = join(dir, "shim.db");
+			const shim = openSqlDb(shimPath);
+			await migrateStore(shim);
+			await shim.close();
+			const fresh = await columnsOf(shimPath);
+
+			for (const table of STORE_TABLES) {
+				const expected = legacy.get(table) ?? new Set<string>();
+				expect(expected.size, `${table} missing from the sqlite bootstrap`).toBeGreaterThan(0);
+				const actual = fresh.get(table) ?? new Set<string>();
+				// Sorted lists, so a failure names the column rather than the sizes.
+				expect([...actual].sort(), table).toEqual([...expected].sort());
+			}
+		} finally {
+			try {
+				rmSync(dir, { recursive: true, force: true });
+			} catch {
+				/* Windows may hold the WAL briefly */
+			}
+		}
+	});
+
+	test("it is idempotent: running it twice changes nothing", async () => {
+		const dir = mkdtempSync(join(tmpdir(), "amr-schema-idem-"));
+		try {
+			const path = join(dir, "twice.db");
+			const db = openSqlDb(path);
+			await migrateStore(db);
+			await migrateStore(db);
+			await db.close();
+			const after = await columnsOf(path);
+			expect(after.get("ledger")?.has("redactions")).toBe(true);
+			expect(after.get("conversations")?.has("cache_warm_slug")).toBe(true);
+		} finally {
+			try {
+				rmSync(dir, { recursive: true, force: true });
+			} catch {
+				/* as above */
+			}
+		}
+	});
+
+	test.skipIf(PG === undefined)("it applies to postgres, twice, with the same columns as sqlite", async () => {
+		const pg = openSqlDb(PG as string);
+		try {
+			for (const table of [...STORE_TABLES].reverse()) await pg.sql.unsafe(`DROP TABLE IF EXISTS ${table}`);
+			await migrateStore(pg);
+			await migrateStore(pg);
+		} finally {
+			await pg.close();
+		}
+		const dir = mkdtempSync(join(tmpdir(), "amr-schema-pg-"));
+		try {
+			const litePath = join(dir, "lite.db");
+			const lite = openSqlDb(litePath);
+			await migrateStore(lite);
+			await lite.close();
+
+			const onPg = await columnsOf(PG as string);
+			const onLite = await columnsOf(litePath);
+			for (const table of STORE_TABLES) {
+				expect([...(onPg.get(table) ?? [])].sort(), table).toEqual([...(onLite.get(table) ?? [])].sort());
+			}
+		} finally {
+			try {
+				rmSync(dir, { recursive: true, force: true });
+			} catch {
+				/* as above */
+			}
+		}
+	});
+});

package/test/scope.test.ts

@@ -3,7 +3,7 @@ import { ORIGIN_ENV, SCOPE_ENV, acceptOrigin, acceptScope, isOrigin, isScopeSlug
 import { parseChatRequest } from "../src/wire/openai/request.ts";
 
 describe("the scope a request may name", () => {
-	test("a slug passes; the env-var sentinel and other non-slugs do not", () => {
+	test("a slug passes; the env-var sentinel and other non-slugs do not", async () => {
 		expect(isScopeSlug("omp-router")).toBe(true);
 		expect(isScopeSlug("ashlands")).toBe(true);
 		expect(isScopeSlug("my.app_v2")).toBe(true);
@@ -16,20 +16,20 @@ describe("the scope a request may name", () => {
 		expect(isScopeSlug("a".repeat(129))).toBe(false);
 	});
 
-	test("acceptScope trims and rejects", () => {
+	test("acceptScope trims and rejects", async () => {
 		expect(acceptScope(" omp-router ")).toBe("omp-router");
 		expect(acceptScope(SCOPE_ENV)).toBe("");
 		expect(acceptScope(null)).toBe("");
 	});
 
-	test("the wire parser drops a non-slug X-Agentdox-Scope", () => {
+	test("the wire parser drops a non-slug X-Agentdox-Scope", async () => {
 		const body = { model: "auto", messages: [{ role: "user", content: "hi" }] };
 		const parse = (scope: string) => parseChatRequest(body, new Headers({ "x-agentdox-scope": scope }));
 		expect(parse("omp-router").agentdoxScope).toBe("omp-router");
 		expect(parse(SCOPE_ENV).agentdoxScope).toBe("");
 	});
 
-	test("the wire parser reads X-Agentdox-Group and X-Agentdox-Personal by the same rule", () => {
+	test("the wire parser reads X-Agentdox-Group and X-Agentdox-Personal by the same rule", async () => {
 		// A team front door names the group-context and personal scopes; a
 		// lone router never sees the headers and must end up with empties, so
 		// nothing new is sent to agentdox.
@@ -51,7 +51,7 @@ describe("the scope a request may name", () => {
 });
 
 describe("the origin a request may name", () => {
-	test("normalizeOrigin reduces every remote form to host/path, and a local path to nothing", () => {
+	test("normalizeOrigin reduces every remote form to host/path, and a local path to nothing", async () => {
 		// The same repository over https and ssh is one fingerprint.
 		expect(normalizeOrigin("https://github.com/DrewAppling/omp-router.git")).toBe("github.com/drewappling/omp-router");
 		expect(normalizeOrigin("git@github.com:drewappling/omp-router.git")).toBe("github.com/drewappling/omp-router");
@@ -70,7 +70,7 @@ describe("the origin a request may name", () => {
 		expect(normalizeOrigin("")).toBe("");
 	});
 
-	test("isOrigin: host/path only; the env-var sentinel never passes", () => {
+	test("isOrigin: host/path only; the env-var sentinel never passes", async () => {
 		expect(isOrigin("github.com/drewappling/omp-router")).toBe(true);
 		expect(isOrigin("gitlab.example.com/team/sub/api")).toBe(true);
 		// omp sends the header's literal value when the variable it names is
@@ -83,14 +83,14 @@ describe("the origin a request may name", () => {
 		expect(isOrigin("")).toBe(false);
 	});
 
-	test("acceptOrigin trims and rejects", () => {
+	test("acceptOrigin trims and rejects", async () => {
 		expect(acceptOrigin(" github.com/a/b ")).toBe("github.com/a/b");
 		expect(acceptOrigin(ORIGIN_ENV)).toBe("");
 		expect(acceptOrigin("https://github.com/a/b")).toBe("");
 		expect(acceptOrigin(null)).toBe("");
 	});
 
-	test("the wire parser reads X-Agentdox-Origin by that rule and nothing else changes", () => {
+	test("the wire parser reads X-Agentdox-Origin by that rule and nothing else changes", async () => {
 		const body = { model: "auto", messages: [{ role: "user", content: "hi" }] };
 		const parse = (h: Record<string, string>) => parseChatRequest(body, new Headers(h));
 		expect(parse({ "x-agentdox-scope": "omp-router" }).agentdoxOrigin).toBe("");