@storyshelf/core 0.3.1 → 0.5.3

package/dist/test-helpers/create-project.mjs

@@ -0,0 +1,28 @@
+import "node:path";
+import "node:url";
+import.meta.url;
+import { BuildModel } from "../models/build.mjs";
+import { ProjectModel } from "../models/project.mjs";
+//#region src/test-helpers/create-project.ts
+/** Create a test project with owner/repo defaults. */
+async function createTestProject(db, tables, overrides) {
+	const { gitRepository: repo, ...rest } = overrides ?? {};
+	const gitRepository = repo ?? "owner/repo";
+	return await new ProjectModel(db, tables).create({
+		name: "Test",
+		gitRepository,
+		...rest
+	});
+}
+/** Create a test build on main with sha-1 defaults. */
+async function createTestBuild(db, tables, projectId, overrides) {
+	return await new BuildModel(db, tables).create(projectId, {
+		gitSha: "sha-1",
+		gitBranch: "main",
+		...overrides
+	});
+}
+//#endregion
+export { createTestBuild, createTestProject };
+
+//# sourceMappingURL=create-project.mjs.map

package/dist/test-helpers/create-project.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-project.mjs","names":[],"sources":["../../src/test-helpers/create-project.ts"],"sourcesContent":["import type { DatabaseAdapter } from \"../adapters/database.ts\";\nimport { BuildModel, type BuildTables } from \"../models/build.ts\";\nimport { ProjectModel, type ProjectTables } from \"../models/project.ts\";\nimport type { Build } from \"../schema/build.ts\";\nimport type { Project } from \"../schema/project.ts\";\n\n/** Create a test project with owner/repo defaults. */\nexport async function createTestProject(\n  db: DatabaseAdapter,\n  tables: ProjectTables,\n  overrides?: Partial<Project>,\n): Promise<Project> {\n  const { gitRepository: repo, ...rest } = overrides ?? {};\n  const gitRepository = repo ?? \"owner/repo\";\n  return await new ProjectModel(db, tables).create({ name: \"Test\", gitRepository, ...rest });\n}\n\n/** Create a test build on main with sha-1 defaults. */\nexport async function createTestBuild(\n  db: DatabaseAdapter,\n  tables: BuildTables,\n  projectId: string,\n  overrides?: Partial<Build>,\n): Promise<Build> {\n  return await new BuildModel(db, tables).create(projectId, {\n    gitSha: \"sha-1\",\n    gitBranch: \"main\",\n    ...overrides,\n  } as Parameters<BuildModel[\"create\"]>[1]);\n}\n"],"mappings":";;;;;;;AAOA,eAAsB,kBACpB,IACA,QACA,WACkB;CAClB,MAAM,EAAE,eAAe,MAAM,GAAG,SAAS,aAAa,CAAC;CACvD,MAAM,gBAAgB,QAAQ;CAC9B,OAAO,MAAM,IAAI,aAAa,IAAI,MAAM,CAAC,CAAC,OAAO;EAAE,MAAM;EAAQ;EAAe,GAAG;CAAK,CAAC;AAC3F;;AAGA,eAAsB,gBACpB,IACA,QACA,WACA,WACgB;CAChB,OAAO,MAAM,IAAI,WAAW,IAAI,MAAM,CAAC,CAAC,OAAO,WAAW;EACxD,QAAQ;EACR,WAAW;EACX,GAAG;CACL,CAAwC;AAC1C"}

package/dist/test-helpers/database-contract.d.mts

@@ -0,0 +1,13 @@
+import __tsdown_shims_path from 'node:path';
+import __tsdown_shims_url from 'node:url';
+import { DatabaseAdapter } from "../adapter/database.mjs";
+//#region src/test-helpers/database-contract.d.ts
+/** Tables every adapter must expose (single-sourced from the contract). */
+declare const REQUIRED_TABLES: string[];
+/** Build the adapter under test (sync or async factories both work). */
+type DatabaseFactory = () => DatabaseAdapter | Promise<DatabaseAdapter>;
+/** Run the database contract against a factory. */
+declare function databaseContractSuite(label: string, make: DatabaseFactory): void;
+//#endregion
+export { DatabaseFactory, REQUIRED_TABLES, databaseContractSuite };
+//# sourceMappingURL=database-contract.d.mts.map

package/dist/test-helpers/database-contract.mjs

@@ -0,0 +1,58 @@
+import "node:path";
+import "node:url";
+import.meta.url;
+import { REQUIRED_TABLE_KEYS } from "../adapter/database.mjs";
+import { describe, expect, it } from "vitest";
+//#region src/test-helpers/database-contract.ts
+/**
+* Published database contract suite for first- and third-party adapters.
+*
+* Structural conformance only (identity, table map, methods, lifecycle
+* rule) — row-level CRUD stays per-package because insert shapes differ per
+* dialect schema. A package proves conformance in one line:
+*
+* ```ts
+* import { databaseContractSuite } from "@storyshelf/core/test-helpers";
+* databaseContractSuite("sqlite", () => createSqliteDatabase(":memory:"));
+* ```
+*/
+/** Tables every adapter must expose (single-sourced from the contract). */
+const REQUIRED_TABLES = REQUIRED_TABLE_KEYS;
+const REQUIRED_METHODS = [
+	"insert",
+	"update",
+	"get",
+	"remove",
+	"list",
+	"count",
+	"all"
+];
+/** Run the database contract against a factory. */
+function databaseContractSuite(label, make) {
+	describe(`database contract: ${label}`, () => {
+		it("exposes database metadata", async () => {
+			const adapter = await make();
+			expect(adapter.metadata.category).toBe("database");
+			expect(adapter.metadata.kind.length).toBeGreaterThan(0);
+		});
+		it("exposes the full table map", async () => {
+			const tables = (await make()).tables;
+			for (const table of REQUIRED_TABLES) expect(tables[table], `missing table: ${table}`).toBeDefined();
+		});
+		it("exposes every CRUD method", async () => {
+			const adapter = await make();
+			for (const method of REQUIRED_METHODS) expect(typeof adapter[method]).toBe("function");
+		});
+		it("keeps the lifecycle rule (absent or all three hooks)", async () => {
+			const lifecycle = (await make()).lifecycle;
+			if (lifecycle === void 0) return;
+			expect(typeof lifecycle.setup).toBe("function");
+			expect(typeof lifecycle.teardown).toBe("function");
+			expect(typeof lifecycle.health).toBe("function");
+		});
+	});
+}
+//#endregion
+export { REQUIRED_TABLES, databaseContractSuite };
+
+//# sourceMappingURL=database-contract.mjs.map

package/dist/test-helpers/database-contract.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"database-contract.mjs","names":[],"sources":["../../src/test-helpers/database-contract.ts"],"sourcesContent":["/**\n * Published database contract suite for first- and third-party adapters.\n *\n * Structural conformance only (identity, table map, methods, lifecycle\n * rule) — row-level CRUD stays per-package because insert shapes differ per\n * dialect schema. A package proves conformance in one line:\n *\n * ```ts\n * import { databaseContractSuite } from \"@storyshelf/core/test-helpers\";\n * databaseContractSuite(\"sqlite\", () => createSqliteDatabase(\":memory:\"));\n * ```\n */\nimport { describe, expect, it } from \"vitest\";\nimport type { DatabaseAdapter } from \"../adapters/database.ts\";\nimport { REQUIRED_TABLE_KEYS } from \"../adapters/database.ts\";\n\n/** Tables every adapter must expose (single-sourced from the contract). */\nexport const REQUIRED_TABLES = REQUIRED_TABLE_KEYS;\n\nconst REQUIRED_METHODS = [\"insert\", \"update\", \"get\", \"remove\", \"list\", \"count\", \"all\"];\n\n/** Build the adapter under test (sync or async factories both work). */\nexport type DatabaseFactory = () => DatabaseAdapter | Promise<DatabaseAdapter>;\n\n/** Run the database contract against a factory. */\nexport function databaseContractSuite(label: string, make: DatabaseFactory): void {\n  describe(`database contract: ${label}`, () => {\n    it(\"exposes database metadata\", async () => {\n      const adapter = await make();\n      expect(adapter.metadata.category).toBe(\"database\");\n      expect(adapter.metadata.kind.length).toBeGreaterThan(0);\n    });\n\n    it(\"exposes the full table map\", async () => {\n      const adapter = await make();\n      const tables = adapter.tables as unknown as Record<string, unknown>;\n      for (const table of REQUIRED_TABLES) {\n        expect(tables[table], `missing table: ${table}`).toBeDefined();\n      }\n    });\n\n    it(\"exposes every CRUD method\", async () => {\n      const adapter = await make();\n      for (const method of REQUIRED_METHODS) {\n        expect(typeof (adapter as unknown as Record<string, unknown>)[method]).toBe(\"function\");\n      }\n    });\n\n    it(\"keeps the lifecycle rule (absent or all three hooks)\", async () => {\n      const adapter = await make();\n      const lifecycle = adapter.lifecycle as\n        | { setup?: unknown; teardown?: unknown; health?: unknown }\n        | undefined;\n      if (lifecycle === undefined) {\n        return;\n      }\n      expect(typeof lifecycle.setup).toBe(\"function\");\n      expect(typeof lifecycle.teardown).toBe(\"function\");\n      expect(typeof lifecycle.health).toBe(\"function\");\n    });\n  });\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;AAiBA,MAAa,kBAAkB;AAE/B,MAAM,mBAAmB;CAAC;CAAU;CAAU;CAAO;CAAU;CAAQ;CAAS;AAAK;;AAMrF,SAAgB,sBAAsB,OAAe,MAA6B;CAChF,SAAS,sBAAsB,eAAe;EAC5C,GAAG,6BAA6B,YAAY;GAC1C,MAAM,UAAU,MAAM,KAAK;GAC3B,OAAO,QAAQ,SAAS,QAAQ,CAAC,CAAC,KAAK,UAAU;GACjD,OAAO,QAAQ,SAAS,KAAK,MAAM,CAAC,CAAC,gBAAgB,CAAC;EACxD,CAAC;EAED,GAAG,8BAA8B,YAAY;GAE3C,MAAM,UAAS,MADO,KAAK,EAAA,CACJ;GACvB,KAAK,MAAM,SAAS,iBAClB,OAAO,OAAO,QAAQ,kBAAkB,OAAO,CAAC,CAAC,YAAY;EAEjE,CAAC;EAED,GAAG,6BAA6B,YAAY;GAC1C,MAAM,UAAU,MAAM,KAAK;GAC3B,KAAK,MAAM,UAAU,kBACnB,OAAO,OAAQ,QAA+C,OAAO,CAAC,CAAC,KAAK,UAAU;EAE1F,CAAC;EAED,GAAG,wDAAwD,YAAY;GAErE,MAAM,aAAY,MADI,KAAK,EAAA,CACD;GAG1B,IAAI,cAAc,KAAA,GAChB;GAEF,OAAO,OAAO,UAAU,KAAK,CAAC,CAAC,KAAK,UAAU;GAC9C,OAAO,OAAO,UAAU,QAAQ,CAAC,CAAC,KAAK,UAAU;GACjD,OAAO,OAAO,UAAU,MAAM,CAAC,CAAC,KAAK,UAAU;EACjD,CAAC;CACH,CAAC;AACH"}

package/dist/test-helpers/fake-adapters.d.mts

@@ -0,0 +1,14 @@
+import __tsdown_shims_path from 'node:path';
+import __tsdown_shims_url from 'node:url';
+import { DatabaseAdapter } from "../adapter/database.mjs";
+import { makeDatabase } from "./fake-database.mjs";
+import { FakeStorage, makeStorage } from "./fake-storage.mjs";
+//#region src/test-helpers/fake-adapters.d.ts
+/**
+ * Empty table map for spec/test doubles whose methods never run (OpenAPI
+ * generation, asset serving). Satisfies boot validation without a driver.
+ */
+declare function stubTables(): DatabaseAdapter["tables"];
+//#endregion
+export { type FakeStorage, makeDatabase, makeStorage, stubTables };
+//# sourceMappingURL=fake-adapters.d.mts.map

package/dist/test-helpers/fake-adapters.mjs

@@ -0,0 +1,20 @@
+import "node:path";
+import "node:url";
+import.meta.url;
+import { REQUIRED_TABLE_KEYS } from "../adapter/database.mjs";
+import { makeDatabase } from "./fake-database.mjs";
+import { makeStorage } from "./fake-storage.mjs";
+//#region src/test-helpers/fake-adapters.ts
+/**
+* Empty table map for spec/test doubles whose methods never run (OpenAPI
+* generation, asset serving). Satisfies boot validation without a driver.
+*/
+function stubTables() {
+	const tables = {};
+	for (const key of REQUIRED_TABLE_KEYS) tables[key] = {};
+	return tables;
+}
+//#endregion
+export { makeDatabase, makeStorage, stubTables };
+
+//# sourceMappingURL=fake-adapters.mjs.map

package/dist/test-helpers/fake-adapters.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"fake-adapters.mjs","names":[],"sources":["../../src/test-helpers/fake-adapters.ts"],"sourcesContent":["/**\n * In-memory test doubles for adapter-contract tests.\n *\n * Re-exports the focused fakes so existing imports keep working; new code\n * should import `fake-storage.ts`, `fake-database.ts`, or `sql-chunks.ts`\n * directly.\n */\nimport type { DatabaseAdapter } from \"../adapters/database.ts\";\nimport { REQUIRED_TABLE_KEYS } from \"../adapters/database.ts\";\nexport { makeDatabase } from \"./fake-database.ts\";\nexport { makeStorage, type FakeStorage } from \"./fake-storage.ts\";\n\n/**\n * Empty table map for spec/test doubles whose methods never run (OpenAPI\n * generation, asset serving). Satisfies boot validation without a driver.\n */\nexport function stubTables(): DatabaseAdapter[\"tables\"] {\n  const tables: Record<string, unknown> = {};\n  for (const key of REQUIRED_TABLE_KEYS) {\n    tables[key] = {};\n  }\n  return tables as unknown as DatabaseAdapter[\"tables\"];\n}\n"],"mappings":";;;;;;;;;;;AAgBA,SAAgB,aAAwC;CACtD,MAAM,SAAkC,CAAC;CACzC,KAAK,MAAM,OAAO,qBAChB,OAAO,OAAO,CAAC;CAEjB,OAAO;AACT"}

package/dist/test-helpers/fake-database.d.mts

@@ -0,0 +1,11 @@
+import __tsdown_shims_path from 'node:path';
+import __tsdown_shims_url from 'node:url';
+import { DatabaseAdapter } from "../adapter/database.mjs";
+//#region src/test-helpers/fake-database.d.ts
+/** Create an in-memory database adapter for capture pipeline tests. */
+declare function makeDatabase(): {
+  db: DatabaseAdapter;
+};
+//#endregion
+export { makeDatabase };
+//# sourceMappingURL=fake-database.d.mts.map

package/dist/test-helpers/fake-database.mjs

@@ -0,0 +1,104 @@
+import "node:path";
+import "node:url";
+import.meta.url;
+import { clampListLimit } from "../adapter/database.mjs";
+import { fakeSchema } from "./fake-tables.mjs";
+import { orderRows, whereMatches } from "./sql-chunks.mjs";
+//#region src/test-helpers/fake-database.ts
+function withoutUndefined(values) {
+	return Object.fromEntries(Object.entries(values).filter((pair) => pair[1] !== void 0));
+}
+/** Create an in-memory database adapter for capture pipeline tests. */
+function makeDatabase() {
+	const store = /* @__PURE__ */ new Map();
+	const rowsOf = (table) => {
+		let rowMap = store.get(table);
+		if (!rowMap) {
+			rowMap = /* @__PURE__ */ new Map();
+			store.set(table, rowMap);
+		}
+		return rowMap;
+	};
+	const insertRow = async (table, values) => {
+		const row = withoutUndefined(values);
+		const key = row["id"] ?? row["hash"];
+		rowsOf(table).set(key, row);
+		return row;
+	};
+	const updateRow = async (table, id, values) => {
+		const current = rowsOf(table).get(id);
+		if (current === void 0) throw new Error("row not found");
+		const merged = withoutUndefined({
+			...current,
+			...values
+		});
+		rowsOf(table).set(id, merged);
+		return merged;
+	};
+	const getRow = async (table, id) => {
+		const found = rowsOf(table).get(id);
+		if (found === void 0) return null;
+		return found;
+	};
+	const listRows = async (table, opts = {}) => {
+		let current = [...rowsOf(table).values()];
+		if (opts.where) {
+			const { where } = opts;
+			current = current.filter((row) => whereMatches(where, row, table));
+		}
+		if (opts.orderBy) current = orderRows(current, opts.orderBy, table);
+		if (opts.limit !== void 0) current = current.slice(0, clampListLimit(opts.limit));
+		return current;
+	};
+	const countRows = async (table, where) => {
+		return (await listRows(table, where ? { where } : {})).length;
+	};
+	const transactRows = async (fn) => {
+		const snapshot = /* @__PURE__ */ new Map();
+		for (const [table, rows] of store) snapshot.set(table, new Map([...rows].map(([id, row]) => [id, { ...row }])));
+		const tx = {
+			insert: insertRow,
+			update: updateRow,
+			get: getRow,
+			remove: async (table, id) => {
+				rowsOf(table).delete(id);
+			},
+			list: listRows,
+			count: countRows
+		};
+		try {
+			return await fn(tx);
+		} catch (error) {
+			store.clear();
+			for (const [table, rows] of snapshot) store.set(table, rows);
+			throw error;
+		}
+	};
+	return { db: {
+		metadata: {
+			name: "Fake Database",
+			version: "0.0.0",
+			kind: "memory",
+			category: "database"
+		},
+		tables: fakeSchema,
+		insert: insertRow,
+		update: updateRow,
+		get: getRow,
+		remove: async (table, id) => {
+			rowsOf(table).delete(id);
+		},
+		list: listRows,
+		count: countRows,
+		transact: transactRows,
+		all: async (_query) => {
+			const results = [];
+			for (const rows of store.values()) for (const row of rows.values()) results.push(row);
+			return results;
+		}
+	} };
+}
+//#endregion
+export { makeDatabase };
+
+//# sourceMappingURL=fake-database.mjs.map

package/dist/test-helpers/fake-database.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"fake-database.mjs","names":[],"sources":["../../src/test-helpers/fake-database.ts"],"sourcesContent":["import type { SQL, Table } from \"drizzle-orm\";\nimport type { DatabaseAdapter, ListOptions, TxStore } from \"../adapters/database.ts\";\nimport { clampListLimit } from \"../adapters/database.ts\";\nimport { fakeSchema } from \"./fake-tables.ts\";\nimport { orderRows, whereMatches } from \"./sql-chunks.ts\";\n\nfunction withoutUndefined(values: unknown): Record<string, unknown> {\n  return Object.fromEntries(\n    Object.entries(values as Record<string, unknown>).filter((pair) => pair[1] !== undefined),\n  );\n}\n\n// The in-memory fake back-fills Drizzle's inferred row types from raw maps\n// Without a driver, so the casts and await-free `async` methods are unavoidable.\n/* eslint-disable require-await, no-unnecessary-type-assertion, no-unnecessary-type-parameters, non-nullable-type-assertion-style */\n/** Create an in-memory database adapter for capture pipeline tests. */\nexport function makeDatabase(): { db: DatabaseAdapter } {\n  const store = new Map<Table, Map<string, unknown>>();\n\n  const rowsOf = (table: Table): Map<string, unknown> => {\n    let rowMap = store.get(table);\n    if (!rowMap) {\n      rowMap = new Map();\n      store.set(table, rowMap);\n    }\n    return rowMap;\n  };\n\n  const insertRow = async <T extends Table>(\n    table: T,\n    values: T[\"$inferInsert\"],\n  ): Promise<T[\"$inferSelect\"]> => {\n    const row = withoutUndefined(values);\n    const key = (row[\"id\"] ?? row[\"hash\"]) as string;\n    rowsOf(table).set(key, row);\n    return row as T[\"$inferSelect\"];\n  };\n\n  const updateRow = async <T extends Table>(\n    table: T,\n    id: string,\n    values: Partial<T[\"$inferInsert\"]>,\n  ): Promise<T[\"$inferSelect\"]> => {\n    const current = rowsOf(table).get(id) as Record<string, unknown> | undefined;\n    if (current === undefined) {\n      throw new Error(\"row not found\");\n    }\n    const merged = withoutUndefined({ ...current, ...values });\n    rowsOf(table).set(id, merged);\n    return merged as T[\"$inferSelect\"];\n  };\n\n  const getRow = async <T extends Table>(\n    table: T,\n    id: string,\n  ): Promise<T[\"$inferSelect\"] | null> => {\n    const found = rowsOf(table).get(id);\n    if (found === undefined) {\n      return null;\n    }\n    return found as T[\"$inferSelect\"];\n  };\n\n  const listRows = async <T extends Table>(\n    table: T,\n    opts: ListOptions = {},\n  ): Promise<T[\"$inferSelect\"][]> => {\n    let current = [...rowsOf(table).values()];\n    if (opts.where) {\n      const { where } = opts;\n      current = current.filter((row) => whereMatches(where, row as Record<string, unknown>, table));\n    }\n    if (opts.orderBy) {\n      current = orderRows(current, opts.orderBy, table);\n    }\n    if (opts.limit !== undefined) {\n      current = current.slice(0, clampListLimit(opts.limit));\n    }\n    return current as T[\"$inferSelect\"][];\n  };\n\n  const countRows = async (table: Table, where?: SQL): Promise<number> => {\n    const matching = await listRows(table, where ? { where } : {});\n    return matching.length;\n  };\n\n  const transactRows = async <R>(fn: (tx: TxStore) => Promise<R>): Promise<R> => {\n    const snapshot = new Map<Table, Map<string, unknown>>();\n    for (const [table, rows] of store) {\n      snapshot.set(\n        table,\n        new Map([...rows].map(([id, row]) => [id, { ...(row as Record<string, unknown>) }])),\n      );\n    }\n    const tx: TxStore = {\n      insert: insertRow,\n      update: updateRow,\n      get: getRow,\n      remove: async (table, id) => {\n        rowsOf(table).delete(id);\n      },\n      list: listRows,\n      count: countRows,\n    };\n    try {\n      return await fn(tx);\n    } catch (error) {\n      store.clear();\n      for (const [table, rows] of snapshot) {\n        store.set(table, rows);\n      }\n      throw error;\n    }\n  };\n\n  const db: DatabaseAdapter = {\n    metadata: { name: \"Fake Database\", version: \"0.0.0\", kind: \"memory\", category: \"database\" },\n    tables: fakeSchema,\n    insert: insertRow,\n    update: updateRow,\n    get: getRow,\n    remove: async (table, id) => {\n      rowsOf(table).delete(id);\n    },\n    list: listRows,\n    count: countRows,\n    transact: transactRows,\n    all: async (_query: SQL) => {\n      const results: Record<string, unknown>[] = [];\n      for (const rows of store.values()) {\n        for (const row of rows.values()) {\n          results.push(row as Record<string, unknown>);\n        }\n      }\n      return results as never[];\n    },\n  };\n  return { db };\n}\n/* eslint-enable require-await, no-unnecessary-type-assertion, no-unnecessary-type-parameters, non-nullable-type-assertion-style */\n"],"mappings":"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"}

package/dist/test-helpers/fake-storage.d.mts

@@ -0,0 +1,14 @@
+import __tsdown_shims_path from 'node:path';
+import __tsdown_shims_url from 'node:url';
+import { StorageAdapter } from "../adapter/storage.mjs";
+//#region src/test-helpers/fake-storage.d.ts
+/** Storage and database doubles used by the capture pipeline tests. */
+interface FakeStorage {
+  storage: StorageAdapter;
+  objects: Map<string, Buffer>;
+}
+/** Create an in-memory storage adapter for capture pipeline tests. */
+declare function makeStorage(): FakeStorage;
+//#endregion
+export { FakeStorage, makeStorage };
+//# sourceMappingURL=fake-storage.d.mts.map

package/dist/test-helpers/fake-storage.mjs

@@ -0,0 +1,49 @@
+import "node:path";
+import "node:url";
+import.meta.url;
+import { Readable } from "node:stream";
+//#region src/test-helpers/fake-storage.ts
+/** Create an in-memory storage adapter for capture pipeline tests. */
+function makeStorage() {
+	const objects = /* @__PURE__ */ new Map();
+	return {
+		storage: {
+			metadata: {
+				name: "Fake Storage",
+				version: "0.0.0",
+				kind: "memory",
+				category: "storage"
+			},
+			read: async (path) => {
+				const found = objects.get(path);
+				if (found === void 0) throw new Error(`no object at "${path}"`);
+				return await Promise.resolve(found);
+			},
+			write: async (path, data) => {
+				objects.set(path, Buffer.from(data));
+				await Promise.resolve();
+			},
+			delete: async (path) => {
+				objects.delete(path);
+				await Promise.resolve();
+			},
+			exists: async (path) => await Promise.resolve(objects.has(path)),
+			list: async (prefix) => await Promise.resolve([...objects.keys()].filter((key) => key.startsWith(prefix)).toSorted()),
+			writeStream: async (path, stream) => {
+				const chunks = [];
+				for await (const chunk of stream) chunks.push(typeof chunk === "string" ? Buffer.from(chunk) : Buffer.from(chunk));
+				objects.set(path, Buffer.concat(chunks));
+			},
+			readStream: async (path) => {
+				const found = objects.get(path);
+				if (found === void 0) throw new Error(`no object at "${path}"`);
+				return await Promise.resolve(Readable.from([found]));
+			}
+		},
+		objects
+	};
+}
+//#endregion
+export { makeStorage };
+
+//# sourceMappingURL=fake-storage.mjs.map

package/dist/test-helpers/fake-storage.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"fake-storage.mjs","names":[],"sources":["../../src/test-helpers/fake-storage.ts"],"sourcesContent":["import { Readable } from \"node:stream\";\nimport type { StorageAdapter } from \"../adapters/storage.ts\";\n\n/** Storage and database doubles used by the capture pipeline tests. */\nexport interface FakeStorage {\n  storage: StorageAdapter;\n  objects: Map<string, Buffer>;\n}\n\n/** Create an in-memory storage adapter for capture pipeline tests. */\nexport function makeStorage(): FakeStorage {\n  const objects = new Map<string, Buffer>();\n  const storage: StorageAdapter = {\n    metadata: { name: \"Fake Storage\", version: \"0.0.0\", kind: \"memory\", category: \"storage\" },\n    read: async (path) => {\n      const found = objects.get(path);\n      if (found === undefined) {\n        throw new Error(`no object at \"${path}\"`);\n      }\n      return await Promise.resolve(found);\n    },\n    write: async (path, data) => {\n      objects.set(path, Buffer.from(data));\n      await Promise.resolve();\n    },\n    delete: async (path) => {\n      objects.delete(path);\n      await Promise.resolve();\n    },\n    exists: async (path) => await Promise.resolve(objects.has(path)),\n    list: async (prefix) =>\n      await Promise.resolve([...objects.keys()].filter((key) => key.startsWith(prefix)).toSorted()),\n    writeStream: async (path, stream) => {\n      const chunks: Buffer[] = [];\n      for await (const chunk of stream) {\n        chunks.push(\n          typeof chunk === \"string\" ? Buffer.from(chunk) : Buffer.from(chunk as Uint8Array),\n        );\n      }\n      objects.set(path, Buffer.concat(chunks));\n    },\n    readStream: async (path) => {\n      const found = objects.get(path);\n      if (found === undefined) {\n        throw new Error(`no object at \"${path}\"`);\n      }\n      return await Promise.resolve(Readable.from([found]));\n    },\n  };\n  return { storage, objects };\n}\n"],"mappings":";;;;;;AAUA,SAAgB,cAA2B;CACzC,MAAM,0BAAU,IAAI,IAAoB;CAsCxC,OAAO;EAAE,SAAA;GApCP,UAAU;IAAE,MAAM;IAAgB,SAAS;IAAS,MAAM;IAAU,UAAU;GAAU;GACxF,MAAM,OAAO,SAAS;IACpB,MAAM,QAAQ,QAAQ,IAAI,IAAI;IAC9B,IAAI,UAAU,KAAA,GACZ,MAAM,IAAI,MAAM,iBAAiB,KAAK,EAAE;IAE1C,OAAO,MAAM,QAAQ,QAAQ,KAAK;GACpC;GACA,OAAO,OAAO,MAAM,SAAS;IAC3B,QAAQ,IAAI,MAAM,OAAO,KAAK,IAAI,CAAC;IACnC,MAAM,QAAQ,QAAQ;GACxB;GACA,QAAQ,OAAO,SAAS;IACtB,QAAQ,OAAO,IAAI;IACnB,MAAM,QAAQ,QAAQ;GACxB;GACA,QAAQ,OAAO,SAAS,MAAM,QAAQ,QAAQ,QAAQ,IAAI,IAAI,CAAC;GAC/D,MAAM,OAAO,WACX,MAAM,QAAQ,QAAQ,CAAC,GAAG,QAAQ,KAAK,CAAC,CAAC,CAAC,QAAQ,QAAQ,IAAI,WAAW,MAAM,CAAC,CAAC,CAAC,SAAS,CAAC;GAC9F,aAAa,OAAO,MAAM,WAAW;IACnC,MAAM,SAAmB,CAAC;IAC1B,WAAW,MAAM,SAAS,QACxB,OAAO,KACL,OAAO,UAAU,WAAW,OAAO,KAAK,KAAK,IAAI,OAAO,KAAK,KAAmB,CAClF;IAEF,QAAQ,IAAI,MAAM,OAAO,OAAO,MAAM,CAAC;GACzC;GACA,YAAY,OAAO,SAAS;IAC1B,MAAM,QAAQ,QAAQ,IAAI,IAAI;IAC9B,IAAI,UAAU,KAAA,GACZ,MAAM,IAAI,MAAM,iBAAiB,KAAK,EAAE;IAE1C,OAAO,MAAM,QAAQ,QAAQ,SAAS,KAAK,CAAC,KAAK,CAAC,CAAC;GACrD;EAEa;EAAG;CAAQ;AAC5B"}

package/dist/test-helpers/fake-tables.mjs

@@ -0,0 +1,276 @@
+import "node:path";
+import "node:url";
+import.meta.url;
+import { Column, Table } from "drizzle-orm";
+//#region src/test-helpers/fake-tables.ts
+/**
+* Dialect-free stub tables for the in-memory test fake.
+*
+* The fake never touches a driver: it only needs table handles whose columns
+* carry the property → column-name mapping (`getTableColumns`) and flow
+* through drizzle's expression builders (`eq`, `and`, `inArray`, `orderBy`)
+* into the `sql-chunks.ts` matcher. Real `Column`/`Table` base classes from
+* the `drizzle-orm` root (already a core dependency) satisfy both without
+* pulling in any dialect package (`sqlite-core`, `pg-core`, …).
+*/
+/** A column handle with driver passthrough mapping (the fake maps nothing). */
+var FakeColumn = class extends Column {
+	getSQLType() {
+		return this.columnType;
+	}
+};
+const columnsSymbol = Table.Symbol.Columns;
+function defineTable(name, columns) {
+	const table = new Table(name, void 0, name);
+	const handles = {};
+	for (const [property, dbName] of Object.entries(columns)) handles[property] = new FakeColumn(table, {
+		name: dbName,
+		keyAsName: false,
+		notNull: false,
+		default: void 0,
+		defaultFn: void 0,
+		onUpdateFn: void 0,
+		hasDefault: false,
+		primaryKey: false,
+		isUnique: false,
+		uniqueName: void 0,
+		uniqueType: void 0,
+		dataType: "string",
+		columnType: "FakeColumn",
+		generated: void 0,
+		generatedIdentity: void 0
+	});
+	table[columnsSymbol] = handles;
+	return table;
+}
+/** Stub schema bundled into the `Tables` map every fake serves. */
+const fakeSchema = {
+	projects: defineTable("projects", {
+		id: "id",
+		name: "name",
+		slug: "slug",
+		gitRepository: "git_repository",
+		gitDefaultBranch: "git_default_branch",
+		pixelThreshold: "pixel_threshold",
+		maxDiffRatio: "max_diff_ratio",
+		publicBranchRegex: "public_branch_regex",
+		storybookMeta: "storybook_meta",
+		executePlay: "execute_play",
+		playTimeoutMs: "play_timeout_ms",
+		runA11y: "run_a11y",
+		browser: "browser",
+		viewports: "viewports",
+		automigrate: "automigrate",
+		createdAt: "created_at",
+		updatedAt: "updated_at"
+	}),
+	projectStatusConfigs: defineTable("project_status_configs", {
+		id: "id",
+		projectId: "project_id",
+		provider: "provider",
+		config: "config",
+		tokenEncrypted: "token_encrypted",
+		createdAt: "created_at",
+		updatedAt: "updated_at"
+	}),
+	builds: defineTable("builds", {
+		id: "id",
+		projectId: "project_id",
+		gitSha: "git_sha",
+		gitBranch: "git_branch",
+		isDefault: "is_default",
+		authorEmail: "author_email",
+		authorName: "author_name",
+		message: "message",
+		public: "public",
+		status: "status",
+		snapshotCount: "snapshot_count",
+		changedCount: "changed_count",
+		approvedCount: "approved_count",
+		rejectedCount: "rejected_count",
+		affectedOnly: "affected_only",
+		baselineSha: "baseline_sha",
+		changedFiles: "changed_files",
+		affectedImportPaths: "affected_import_paths",
+		createdAt: "created_at",
+		updatedAt: "updated_at"
+	}),
+	captureAttempts: defineTable("capture_attempts", {
+		id: "id",
+		projectId: "project_id",
+		buildId: "build_id",
+		attemptNo: "attempt_no",
+		status: "status",
+		error: "error",
+		reqId: "req_id",
+		storyCount: "story_count",
+		failedCount: "failed_count",
+		queuedAt: "queued_at",
+		startedAt: "started_at",
+		finishedAt: "finished_at",
+		createdAt: "created_at",
+		updatedAt: "updated_at"
+	}),
+	captureLogs: defineTable("capture_logs", {
+		id: "id",
+		projectId: "project_id",
+		buildId: "build_id",
+		attemptId: "attempt_id",
+		seq: "seq",
+		level: "level",
+		message: "message",
+		fields: "fields",
+		createdAt: "created_at"
+	}),
+	snapshots: defineTable("snapshots", {
+		id: "id",
+		projectId: "project_id",
+		buildId: "build_id",
+		storyId: "story_id",
+		storyName: "story_name",
+		storyTitle: "story_title",
+		storyImportPath: "story_import_path",
+		viewportName: "viewport_name",
+		viewportWidth: "viewport_width",
+		viewportHeight: "viewport_height",
+		screenshotPath: "screenshot_path",
+		diffPath: "diff_path",
+		diffPixels: "diff_pixels",
+		diffRatio: "diff_ratio",
+		diffPassed: "diff_passed",
+		status: "status",
+		reviewedBy: "reviewed_by",
+		reviewedAt: "reviewed_at",
+		infraHash: "infra_hash",
+		inherited: "inherited",
+		baselineId: "baseline_id",
+		baselineVersion: "baseline_version",
+		createdAt: "created_at",
+		updatedAt: "updated_at"
+	}),
+	baselines: defineTable("baselines", {
+		id: "id",
+		projectId: "project_id",
+		storyId: "story_id",
+		viewportName: "viewport_name",
+		branch: "branch",
+		snapshotId: "snapshot_id",
+		screenshotPath: "screenshot_path",
+		infraHash: "infra_hash",
+		createdAt: "created_at",
+		updatedAt: "updated_at"
+	}),
+	comments: defineTable("comments", {
+		id: "id",
+		projectId: "project_id",
+		buildId: "build_id",
+		snapshotId: "snapshot_id",
+		userId: "user_id",
+		body: "body",
+		parentId: "parent_id",
+		resolved: "resolved",
+		createdAt: "created_at",
+		updatedAt: "updated_at"
+	}),
+	labelTypes: defineTable("label_types", {
+		id: "id",
+		projectId: "project_id",
+		key: "key",
+		name: "name",
+		linkTemplate: "link_template",
+		color: "color",
+		createdAt: "created_at"
+	}),
+	buildLabels: defineTable("build_labels", {
+		id: "id",
+		projectId: "project_id",
+		buildId: "build_id",
+		typeKey: "type_key",
+		value: "value",
+		createdAt: "created_at"
+	}),
+	tokens: defineTable("tokens", {
+		id: "id",
+		projectId: "project_id",
+		name: "name",
+		hash: "hash",
+		userId: "user_id",
+		lastUsedAt: "last_used_at",
+		createdAt: "created_at"
+	}),
+	webhooks: defineTable("webhooks", {
+		id: "id",
+		projectId: "project_id",
+		url: "url",
+		secretEncrypted: "secret_encrypted",
+		events: "events",
+		createdAt: "created_at",
+		updatedAt: "updated_at"
+	}),
+	users: defineTable("users", {
+		id: "id",
+		email: "email",
+		name: "name",
+		avatarUrl: "avatar_url",
+		role: "role",
+		lastLoginAt: "last_login_at",
+		createdAt: "created_at",
+		passwordHash: "password_hash",
+		displayNameOverride: "display_name_override",
+		authProvider: "auth_provider",
+		disabled: "disabled"
+	}),
+	userInviteTokens: defineTable("user_invite_tokens", {
+		id: "id",
+		userId: "user_id",
+		tokenHash: "token_hash",
+		expiresAt: "expires_at",
+		usedAt: "used_at",
+		createdAt: "created_at"
+	}),
+	projectMembers: defineTable("project_members", {
+		id: "id",
+		projectId: "project_id",
+		userId: "user_id",
+		role: "role",
+		source: "source",
+		createdAt: "created_at"
+	}),
+	projectGroupMappings: defineTable("project_group_mappings", {
+		id: "id",
+		projectId: "project_id",
+		groupName: "group_name",
+		role: "role",
+		createdAt: "created_at"
+	}),
+	notificationChannels: defineTable("notification_channels", {
+		id: "id",
+		projectId: "project_id",
+		provider: "provider",
+		config: "config",
+		secretEncrypted: "secret_encrypted",
+		events: "events",
+		enabled: "enabled",
+		createdAt: "created_at",
+		updatedAt: "updated_at"
+	}),
+	notificationSubscriptions: defineTable("notification_subscriptions", {
+		id: "id",
+		projectId: "project_id",
+		userId: "user_id",
+		events: "events",
+		via: "via",
+		enabled: "enabled",
+		createdAt: "created_at"
+	}),
+	contentRefs: defineTable("content_refs", {
+		hash: "hash",
+		refCount: "ref_count",
+		lastSeenAt: "last_seen_at",
+		createdAt: "created_at"
+	})
+};
+//#endregion
+export { fakeSchema };
+
+//# sourceMappingURL=fake-tables.mjs.map