@stratal/testing 0.0.27 → 0.1.0

package/dist/database-Rojs69r3.mjs

@@ -0,0 +1,453 @@
+import { createHash } from "node:crypto";
+import { readFileSync, readdirSync, statSync } from "node:fs";
+import { basename, dirname, join, resolve } from "node:path";
+//#region src/database/test-database.ts
+/**
+* Test database isolation helpers.
+*
+* Implements leased worker databases for parallel runs against Postgres. A
+* migrated **template** database is built once in global setup. Each test file
+* leases one numbered worker database for as long as its isolate lives and
+* receives a fresh clone of the template in it, so a run holds at most as many
+* databases as it runs files at once. See `@stratal/testing/database`.
+*
+* `pg` is imported dynamically so this module loads without it — consumers
+* that don't use a database never pay the dependency.
+*/
+/** Env var carrying the name of the Hyperdrive binding to isolate. */
+const BINDING_ENV_VAR = "STRATAL_TEST_DB_BINDING";
+/** Default Hyperdrive binding name when none is configured. */
+const DEFAULT_DB_BINDING = "DB";
+/**
+* Postgres' identifier length limit. Names longer than this are silently
+* truncated by the server, which would cause distinct logical names to collide
+* on the same physical database. We assert against it everywhere a name is
+* derived.
+*/
+const MAX_IDENTIFIER_LENGTH = 63;
+/** Quote a Postgres identifier for safe interpolation into DDL. */
+function quoteIdent$1(name) {
+	return `"${name.replace(/"/g, "\"\"")}"`;
+}
+/** Quote a Postgres string literal for safe interpolation into SQL. */
+function quoteLiteral(value) {
+	return `'${value.replace(/'/g, "''")}'`;
+}
+/**
+* Dynamically import `pg` (an optional peer), surfacing an actionable error
+* instead of a raw module-not-found when database isolation is requested
+* without the dependency installed.
+*/
+async function importPg$1() {
+	try {
+		const { default: pg } = await import("pg");
+		return pg;
+	} catch (error) {
+		throw new Error("[stratal-testing] `pg` is required for database isolation but is not installed. Install it: `npm install --save-dev pg` (or `yarn add -D pg`).", { cause: error });
+	}
+}
+/**
+* Assert a derived identifier fits within Postgres' {@link MAX_IDENTIFIER_LENGTH}
+* limit. Throws a clear, actionable error instead of letting the server
+* silently truncate and collide names.
+*/
+function assertIdentifierLength(name, kind) {
+	if (name.length > MAX_IDENTIFIER_LENGTH) throw new Error(`[stratal-testing] Derived ${kind} "${name}" is ${name.length} characters, exceeding Postgres' ${MAX_IDENTIFIER_LENGTH}-character identifier limit. Use a shorter base database name so the test-isolation suffix fits.`);
+}
+/** Parse the database name out of a Postgres connection URL. */
+function databaseNameOf(connectionString) {
+	return new URL(connectionString).pathname.replace(/^\//, "") || "postgres";
+}
+/**
+* Derive an admin connection string pointing at the `postgres` maintenance
+* database. `CREATE`/`DROP DATABASE` cannot run on a connection bound to the
+* target database, so administration always goes through `postgres`.
+*/
+function deriveAdminConnectionString(connectionString) {
+	const url = new URL(connectionString);
+	url.pathname = "/postgres";
+	return url.toString();
+}
+/** Build a connection string identical to `base` but pointing at `dbName`. */
+function buildConnectionString(base, dbName) {
+	const url = new URL(base);
+	url.pathname = `/${dbName}`;
+	return url.toString();
+}
+/** The shared prefix for worker databases, used as the sweep key. */
+function databasePrefix(base) {
+	return `${databaseNameOf(base).replace(/[^a-z0-9_]/gi, "_")}_w_`;
+}
+/** Name of the migrated template database cloned per worker. */
+function deriveTemplateName(base) {
+	const name = `${databaseNameOf(base).replace(/[^a-z0-9_]/gi, "_")}_template`;
+	assertIdentifierLength(name, "template database name");
+	return name;
+}
+/**
+* Name of the worker database behind lease `slot`. Asserted against Postgres'
+* 63-char identifier limit (keep the base name short so `_w_<slot>` fits).
+*/
+function deriveWorkerDbName(base, slot) {
+	const name = `${databaseNameOf(base).replace(/[^a-z0-9_]/gi, "_")}_w_${slot}`;
+	assertIdentifierLength(name, "worker database name");
+	return name;
+}
+/** The lease slot a worker database name carries, or `null` for any other name. */
+function slotOfWorkerDb(prefix, dbName) {
+	if (!dbName.startsWith(prefix)) return null;
+	const slot = dbName.slice(prefix.length);
+	return /^\d+$/.test(slot) ? Number(slot) : null;
+}
+/**
+* The advisory-lock key that reserves lease `slot` of `template`. Keyed on the
+* template so two suites with different base databases never compete for slots.
+*/
+function leaseLockKey(template, slot) {
+	return `stratal:worker-db-lease:${template}:${slot}`;
+}
+async function withAdminClient(adminConn, fn) {
+	const client = new (await (importPg$1())).Client({ connectionString: adminConn });
+	await client.connect();
+	try {
+		return await fn((sql) => client.query(sql));
+	} finally {
+		await client.end();
+	}
+}
+/**
+* True for SQLSTATE 55006 ("source database is being accessed by other users") —
+* what `CREATE DATABASE ... TEMPLATE t` raises while another session is using the
+* template (e.g. a concurrent clone of the same template).
+*/
+function isTemplateInUse(error) {
+	return error?.code === "55006";
+}
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+/**
+* Replace worker database `dbName` with a fresh clone of `template`.
+*
+* The clone is serialized across all workers and processes by one Postgres
+* advisory lock keyed on the template. Postgres permits only one
+* `CREATE DATABASE ... TEMPLATE t` at a time — a concurrent one fails with
+* SQLSTATE 55006 — so without the lock every file starting at once would race
+* and all but one would fail. The lock funnels them one at a time, each
+* blocking *in Postgres* (not busy-waiting) until its turn. A create that still
+* hits a transient 55006 is retried with backoff.
+*
+* `WITH (FORCE)` ends connections the previous lessee's pool left open: its
+* isolate is gone, so nothing will close them.
+*/
+async function cloneWorkerDatabase(adminConn, dbName, template) {
+	await withAdminClient(adminConn, async (query) => {
+		const lockKey = quoteLiteral(`stratal:worker-db-clone:${template}`);
+		await query(`SELECT pg_advisory_lock(hashtext(${lockKey}))`);
+		try {
+			await query(`DROP DATABASE IF EXISTS ${quoteIdent$1(dbName)} WITH (FORCE)`);
+			const create = `CREATE DATABASE ${quoteIdent$1(dbName)} TEMPLATE ${quoteIdent$1(template)}`;
+			for (let attempt = 1;; attempt++) try {
+				await query(create);
+				return;
+			} catch (error) {
+				if (isTemplateInUse(error) && attempt < 5) {
+					await sleep(250 * attempt);
+					continue;
+				}
+				throw error;
+			}
+		} finally {
+			await query(`SELECT pg_advisory_unlock(hashtext(${lockKey}))`);
+		}
+	});
+}
+/**
+* The connections holding this isolate's leases. A lease is a session-level
+* advisory lock, so it lasts exactly as long as its connection: kept open here
+* for the isolate's lifetime, it closes — and the slot frees — when the pool
+* disposes the isolate at the end of its test file.
+*/
+const leaseConnections = [];
+/**
+* Lease the lowest free worker database for `base` and fill it with a fresh
+* clone of the template.
+*
+* A slot is free when no other session holds its advisory lock. The pool runs
+* each test file in its own isolate and disposes that isolate when the file
+* ends, so a run never holds more slots than it runs files at once — and so
+* never more worker databases. Every lease re-clones, so a file starts from
+* exactly the template, including anything `prepare` baked into it.
+*/
+async function leaseWorkerDatabase(base) {
+	const pg = await importPg$1();
+	const adminConn = deriveAdminConnectionString(base);
+	const template = deriveTemplateName(base);
+	const client = new pg.Client({ connectionString: adminConn });
+	await client.connect();
+	try {
+		let slot = 0;
+		for (;; slot++) {
+			const { rows } = await client.query(`SELECT pg_try_advisory_lock(hashtext(${quoteLiteral(leaseLockKey(template, slot))})) AS acquired`);
+			if (rows[0]?.acquired) break;
+		}
+		const name = deriveWorkerDbName(base, slot);
+		await cloneWorkerDatabase(adminConn, name, template);
+		leaseConnections.push(client);
+		return {
+			name,
+			connectionString: buildConnectionString(base, name)
+		};
+	} catch (error) {
+		await client.end().catch(() => {});
+		throw error;
+	}
+}
+/**
+* Drop worker databases nobody is using, leaving a concurrent process's live
+* ones intact.
+*
+* Multiple setups can run at once (CI sharding, several e2e projects), so a
+* database is dropped only when it has **no active backend connections** and
+* its lease slot is free. The slot check closes the window between a lease and
+* the lessee's first connection: a just-cloned database has no connections yet
+* but is already spoken for. The sweep takes the slot's lock itself while it
+* drops, so no lease can begin mid-drop.
+*/
+async function sweepStaleDatabases(adminConn, prefix, template) {
+	const likePrefix = prefix.replace(/'/g, "''").replace(/[\\%_]/g, (c) => `\\${c}`);
+	await withAdminClient(adminConn, async (query) => {
+		const { rows } = await query(`SELECT d.datname FROM pg_database d WHERE d.datname LIKE '${likePrefix}%' ESCAPE '\\' AND NOT EXISTS (SELECT 1 FROM pg_stat_activity a WHERE a.datname = d.datname)`);
+		for (const { datname } of rows) {
+			const slot = slotOfWorkerDb(prefix, datname);
+			if (slot === null) continue;
+			const lockKey = quoteLiteral(leaseLockKey(template, slot));
+			const { rows: lock } = await query(`SELECT pg_try_advisory_lock(hashtext(${lockKey})) AS acquired`);
+			if (!lock[0]?.acquired) continue;
+			try {
+				await query(`DROP DATABASE IF EXISTS ${quoteIdent$1(datname)} WITH (FORCE)`);
+			} finally {
+				await query(`SELECT pg_advisory_unlock(hashtext(${lockKey}))`);
+			}
+		}
+	});
+}
+/**
+* Run `fn` while holding a session-level Postgres advisory lock keyed to
+* `lockKey`, serializing template setup across concurrent processes (CI
+* sharding, multiple e2e projects) so they don't drop/recreate the template out
+* from under each other. The lock is released in `finally`.
+*/
+async function withAdvisoryLock(adminConn, lockKey, fn) {
+	return withAdminClient(adminConn, async (query) => {
+		await query(`SELECT pg_advisory_lock(hashtext(${quoteLiteral(lockKey)}))`);
+		try {
+			return await fn();
+		} finally {
+			await query(`SELECT pg_advisory_unlock(hashtext(${quoteLiteral(lockKey)}))`);
+		}
+	});
+}
+/** Schema source file extensions hashed into the template fingerprint. */
+const SCHEMA_FILE_RE = /\.(zmodel|prisma|sql)$/;
+/** Matches ZModel `import "..."` / `import '...'` statements. */
+const ZMODEL_IMPORT_RE = /^\s*import\s+['"]([^'"]+)['"]/gm;
+/**
+* Follow a ZModel file's `import` graph, collecting the root plus every
+* transitively imported `.zmodel` file — ZenStack supports multi-file schemas,
+* so editing an imported file must invalidate the fingerprint. Import paths
+* resolve relative to the importing file; the `.zmodel` extension is optional.
+* A missing import target is skipped (migration surfaces the real error).
+*/
+function collectZmodelImports(file, seen) {
+	if (seen.has(file)) return;
+	let content;
+	try {
+		content = readFileSync(file, "utf8");
+	} catch {
+		return;
+	}
+	seen.add(file);
+	for (const [, importPath] of content.matchAll(ZMODEL_IMPORT_RE)) {
+		const target = resolve(dirname(file), importPath);
+		collectZmodelImports(target.endsWith(".zmodel") ? target : `${target}.zmodel`, seen);
+	}
+}
+/**
+* Expand a schema path into the concrete files to hash. A directory contributes
+* every schema file in its tree; a single `.zmodel` file contributes its whole
+* `import` graph; any other file contributes itself.
+*/
+function collectSchemaFiles(path) {
+	if (statSync(path).isDirectory()) {
+		const out = [];
+		for (const entry of readdirSync(path, { withFileTypes: true })) {
+			const full = join(path, entry.name);
+			if (entry.isDirectory()) out.push(...collectSchemaFiles(full));
+			else if (SCHEMA_FILE_RE.test(entry.name)) out.push(full);
+		}
+		return out;
+	}
+	if (path.endsWith(".zmodel")) {
+		const seen = /* @__PURE__ */ new Set();
+		collectZmodelImports(path, seen);
+		return [...seen];
+	}
+	return [path];
+}
+/**
+* A content-derived fingerprint of the schema source(s) plus the migrate and
+* prepare routines. The template is reused across runs while this is
+* unchanged; any edit to a schema file — or to how migration/preparation run
+* — changes it and forces a rebuild. Uses file basenames (not absolute paths)
+* so it is stable across checkouts.
+*
+* @internal exported for fingerprint unit tests
+*/
+function computeSchemaFingerprint(schema, migrate, prepare) {
+	const roots = Array.isArray(schema) ? schema : [schema];
+	const files = roots.flatMap(collectSchemaFiles).sort();
+	if (files.length === 0) throw new Error(`[stratal-testing] No schema files found for fingerprinting under: ${roots.join(", ")}`);
+	const hash = createHash("sha256");
+	for (const file of files) {
+		hash.update(basename(file));
+		hash.update("\0");
+		hash.update(readFileSync(file));
+		hash.update("\0");
+	}
+	hash.update(migrate.toString());
+	hash.update("\0");
+	hash.update(prepare ? prepare.toString() : "");
+	return hash.digest("hex");
+}
+/**
+* Read the template database's stored schema fingerprint (kept as the database
+* COMMENT). Returns `null` when the template does not exist or carries no
+* fingerprint. Database comments are NOT copied by `CREATE DATABASE ...
+* TEMPLATE`, so worker clones never inherit it.
+*/
+async function readTemplateFingerprint(query, template) {
+	const { rows } = await query(`SELECT shobj_description(oid, 'pg_database') AS fingerprint FROM pg_database WHERE datname = ${quoteLiteral(template)}`);
+	return rows.length === 0 ? null : rows[0].fingerprint;
+}
+/**
+* Build a Vitest `globalSetup` default export that prepares the test database.
+*
+* Under a Postgres advisory lock (so concurrent setups across CI shards /
+* multiple e2e projects don't clobber each other), sweeps unused worker
+* databases, then ensures a migrated (and optionally prepared) template exists
+* — ready to be cloned into each leased worker database.
+*
+* **Template reuse.** The template is fingerprinted from the `schema` source(s)
+* + the `migrate` routine + the `prepare` routine, and the fingerprint is
+* stored as the template's database COMMENT. On each run, a matching
+* fingerprint means nothing has changed and the existing template is reused
+* as-is — `migrate`/`prepare` run **only** on the first run after an edit (or on
+* a fresh database). The fingerprint is stamped only after a successful
+* migrate + prepare, so a match always implies a complete template; there is no
+* force/skip flag — reuse is purely fingerprint-driven.
+*
+* **Concurrency model.** The reuse check + rebuild runs under
+* `pg_advisory_lock(hashtext(<template>))`, so only one process rebuilds the
+* template at a time. The sweep only drops worker databases with **no active
+* connections** and a free lease slot, leaving a sibling process's live databases
+* intact — which is what lets it run at teardown as well as at setup, so a run
+* takes its own databases with it. Teardown deliberately does **not** drop the
+* template: it is shared, and the next run reuses it by fingerprint.
+*
+* @example
+* ```ts
+* // test/global-setup.ts
+* import { createTestDatabaseGlobalSetup } from '@stratal/testing/database'
+*
+* export default createTestDatabaseGlobalSetup({
+*   schema: schemaPath, // file or directory — reused-when-unchanged fingerprint
+*   migrate: (conn) => execFileSync(zenstackBin, ['db', 'push', '--force-reset', `--schema=${schemaPath}`, '--accept-data-loss'],
+*     { env: { ...process.env, DATABASE_URL: conn }, stdio: 'inherit' }),
+* })
+* ```
+*/
+function createTestDatabaseGlobalSetup(opts) {
+	return async () => {
+		const base = opts.connectionString ?? process.env.DATABASE_URL;
+		if (!base) throw new Error("[stratal-testing] No connection string for test database setup. Set process.env.DATABASE_URL or pass `connectionString`.");
+		const adminConn = deriveAdminConnectionString(base);
+		const template = opts.templateName ?? deriveTemplateName(base);
+		const prefix = databasePrefix(base);
+		const leaseTemplate = deriveTemplateName(base);
+		const fingerprint = computeSchemaFingerprint(opts.schema, opts.migrate, opts.prepare);
+		await withAdvisoryLock(adminConn, template, async () => {
+			await sweepStaleDatabases(adminConn, prefix, leaseTemplate);
+			if (await withAdminClient(adminConn, (query) => readTemplateFingerprint(query, template)) === fingerprint) return;
+			await withAdminClient(adminConn, async (query) => {
+				await query(`DROP DATABASE IF EXISTS ${quoteIdent$1(template)} WITH (FORCE)`);
+				await query(`CREATE DATABASE ${quoteIdent$1(template)}`);
+			});
+			const templateConn = buildConnectionString(base, template);
+			await opts.migrate(templateConn);
+			if (opts.prepare) await opts.prepare(templateConn);
+			await withAdminClient(adminConn, (query) => query(`COMMENT ON DATABASE ${quoteIdent$1(template)} IS ${quoteLiteral(fingerprint)}`));
+		});
+		return async () => {
+			await sweepStaleDatabases(adminConn, prefix, leaseTemplate);
+		};
+	};
+}
+//#endregion
+//#region src/database/reset.ts
+function quoteIdent(ident) {
+	return `"${ident.replace(/"/g, "\"\"")}"`;
+}
+/**
+* Build a single `TRUNCATE ... RESTART IDENTITY CASCADE` (empty when no tables).
+* Takes `{ schema, table }` pairs and quotes each part independently, so a
+* dotted identifier (a legal quoted name, e.g. `"my.table"`) is preserved
+* verbatim rather than mis-split into extra qualifier segments.
+*/
+function buildTruncateSql(tables) {
+	if (tables.length === 0) return "";
+	return `TRUNCATE ${tables.map((t) => `${quoteIdent(t.schema)}.${quoteIdent(t.table)}`).join(", ")} RESTART IDENTITY CASCADE`;
+}
+/**
+* Sentinel meaning "the active search-path schema" (`current_schema()`). A
+* Symbol so it can never collide with a real schema name — a schema literally
+* named `current` is passed through as the string literal `'current'`.
+*/
+const CURRENT_SCHEMA = Symbol("current_schema");
+/**
+* Build the SQL that discovers truncatable tables: every base table in the
+* given schemas ({@link CURRENT_SCHEMA} → `current_schema()`), excluding
+* migration bookkeeping (`_prisma%`) and any caller-supplied preserve patterns.
+* Returns a SELECT of `schemaname, tablename`. Escaping lives here so both reset
+* paths share one implementation.
+*/
+function buildTableDiscoverySql(schemas, preserve) {
+	return `SELECT schemaname::text AS schemaname, tablename::text AS tablename FROM pg_tables WHERE schemaname IN (${[CURRENT_SCHEMA, ...schemas].map((s) => typeof s === "symbol" ? "current_schema()" : `'${s.replace(/'/g, "''")}'`).join(", ")}) AND ${["_prisma%", ...preserve].map((p) => `tablename NOT LIKE '${p.replace(/'/g, "''")}'`).join(" AND ")}`;
+}
+async function importPg() {
+	const { default: mod } = await import("pg");
+	return mod;
+}
+/**
+* Reset a worker database between tests: discover every non-preserved table in
+* the target schemas and truncate them in one statement. Fast because the
+* schema/DDL is baked into the worker DB — reset only clears mutable rows and
+* resets identities. Opens and closes a short-lived direct `pg` connection.
+*/
+async function resetWorkerDatabase(connectionString, opts = {}) {
+	const client = new (await (importPg())).Client({ connectionString });
+	await client.connect();
+	try {
+		const sql = buildTableDiscoverySql(opts.schemas ?? [], opts.preserve ?? []);
+		const { rows } = await client.query(sql);
+		const truncateSql = buildTruncateSql(rows.map((r) => ({
+			schema: r.schemaname,
+			table: r.tablename
+		})));
+		if (truncateSql) await client.query(truncateSql);
+	} finally {
+		await client.end();
+	}
+}
+//#endregion
+export { DEFAULT_DB_BINDING as a, createTestDatabaseGlobalSetup as c, deriveTemplateName as d, deriveWorkerDbName as f, BINDING_ENV_VAR as i, databasePrefix as l, buildTruncateSql as n, buildConnectionString as o, leaseWorkerDatabase as p, resetWorkerDatabase as r, cloneWorkerDatabase as s, buildTableDiscoverySql as t, deriveAdminConnectionString as u };
+
+//# sourceMappingURL=database-Rojs69r3.mjs.map

package/dist/database-Rojs69r3.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"database-Rojs69r3.mjs","names":["quoteIdent","importPg"],"sources":["../src/database/test-database.ts","../src/database/reset.ts"],"sourcesContent":["/**\n * Test database isolation helpers.\n *\n * Implements leased worker databases for parallel runs against Postgres. A\n * migrated **template** database is built once in global setup. Each test file\n * leases one numbered worker database for as long as its isolate lives and\n * receives a fresh clone of the template in it, so a run holds at most as many\n * databases as it runs files at once. See `@stratal/testing/database`.\n *\n * `pg` is imported dynamically so this module loads without it — consumers\n * that don't use a database never pay the dependency.\n */\n\nimport { createHash } from 'node:crypto'\nimport { readFileSync, readdirSync, statSync } from 'node:fs'\nimport { basename, dirname, join, resolve } from 'node:path'\n\nimport type pg from 'pg'\n\n/** Env var carrying the name of the Hyperdrive binding to isolate. */\nexport const BINDING_ENV_VAR = 'STRATAL_TEST_DB_BINDING'\n\n/** Default Hyperdrive binding name when none is configured. */\nexport const DEFAULT_DB_BINDING = 'DB'\n\n/**\n * Postgres' identifier length limit. Names longer than this are silently\n * truncated by the server, which would cause distinct logical names to collide\n * on the same physical database. We assert against it everywhere a name is\n * derived.\n */\nconst MAX_IDENTIFIER_LENGTH = 63\n\n/** Quote a Postgres identifier for safe interpolation into DDL. */\nfunction quoteIdent(name: string): string {\n  return `\"${name.replace(/\"/g, '\"\"')}\"`\n}\n\n/** Quote a Postgres string literal for safe interpolation into SQL. */\nfunction quoteLiteral(value: string): string {\n  return `'${value.replace(/'/g, \"''\")}'`\n}\n\n/**\n * Dynamically import `pg` (an optional peer), surfacing an actionable error\n * instead of a raw module-not-found when database isolation is requested\n * without the dependency installed.\n */\nasync function importPg(): Promise<typeof pg> {\n  try {\n    const { default: pg } = await import('pg')\n    return pg\n  } catch (error) {\n    throw new Error(\n      \"[stratal-testing] `pg` is required for database isolation but is not installed. \" +\n        'Install it: `npm install --save-dev pg` (or `yarn add -D pg`).',\n      { cause: error },\n    )\n  }\n}\n\n/**\n * Assert a derived identifier fits within Postgres' {@link MAX_IDENTIFIER_LENGTH}\n * limit. Throws a clear, actionable error instead of letting the server\n * silently truncate and collide names.\n */\nfunction assertIdentifierLength(name: string, kind: string): void {\n  if (name.length > MAX_IDENTIFIER_LENGTH) {\n    throw new Error(\n      `[stratal-testing] Derived ${kind} \"${name}\" is ${name.length} characters, ` +\n        `exceeding Postgres' ${MAX_IDENTIFIER_LENGTH}-character identifier limit. ` +\n        'Use a shorter base database name so the test-isolation suffix fits.',\n    )\n  }\n}\n\n/** Parse the database name out of a Postgres connection URL. */\nfunction databaseNameOf(connectionString: string): string {\n  const name = new URL(connectionString).pathname.replace(/^\\//, '')\n  return name || 'postgres'\n}\n\n/**\n * Derive an admin connection string pointing at the `postgres` maintenance\n * database. `CREATE`/`DROP DATABASE` cannot run on a connection bound to the\n * target database, so administration always goes through `postgres`.\n */\nexport function deriveAdminConnectionString(connectionString: string): string {\n  const url = new URL(connectionString)\n  url.pathname = '/postgres'\n  return url.toString()\n}\n\n/** Build a connection string identical to `base` but pointing at `dbName`. */\nexport function buildConnectionString(base: string, dbName: string): string {\n  const url = new URL(base)\n  url.pathname = `/${dbName}`\n  return url.toString()\n}\n\n/** The shared prefix for worker databases, used as the sweep key. */\nexport function databasePrefix(base: string): string {\n  const baseName = databaseNameOf(base).replace(/[^a-z0-9_]/gi, '_')\n  return `${baseName}_w_`\n}\n\n/** Name of the migrated template database cloned per worker. */\nexport function deriveTemplateName(base: string): string {\n  const name = `${databaseNameOf(base).replace(/[^a-z0-9_]/gi, '_')}_template`\n  assertIdentifierLength(name, 'template database name')\n  return name\n}\n\n/**\n * Name of the worker database behind lease `slot`. Asserted against Postgres'\n * 63-char identifier limit (keep the base name short so `_w_<slot>` fits).\n */\nexport function deriveWorkerDbName(base: string, slot: number): string {\n  const baseName = databaseNameOf(base).replace(/[^a-z0-9_]/gi, '_')\n  const name = `${baseName}_w_${slot}`\n  assertIdentifierLength(name, 'worker database name')\n  return name\n}\n\n/** The lease slot a worker database name carries, or `null` for any other name. */\nfunction slotOfWorkerDb(prefix: string, dbName: string): number | null {\n  if (!dbName.startsWith(prefix)) return null\n  const slot = dbName.slice(prefix.length)\n  return /^\\d+$/.test(slot) ? Number(slot) : null\n}\n\n/**\n * The advisory-lock key that reserves lease `slot` of `template`. Keyed on the\n * template so two suites with different base databases never compete for slots.\n */\nfunction leaseLockKey(template: string, slot: number): string {\n  return `stratal:worker-db-lease:${template}:${slot}`\n}\n\nasync function withAdminClient<T>(adminConn: string, fn: (query: (sql: string) => Promise<unknown>) => Promise<T>): Promise<T> {\n  const pg = await importPg()\n  const client = new pg.Client({ connectionString: adminConn })\n  await client.connect()\n  try {\n    return await fn((sql) => client.query(sql))\n  } finally {\n    await client.end()\n  }\n}\n\n/**\n * True for SQLSTATE 55006 (\"source database is being accessed by other users\") —\n * what `CREATE DATABASE ... TEMPLATE t` raises while another session is using the\n * template (e.g. a concurrent clone of the same template).\n */\nfunction isTemplateInUse(error: unknown): boolean {\n  return (error as { code?: string })?.code === '55006'\n}\n\nconst sleep = (ms: number): Promise<void> => new Promise((resolve) => setTimeout(resolve, ms))\n\n/**\n * Replace worker database `dbName` with a fresh clone of `template`.\n *\n * The clone is serialized across all workers and processes by one Postgres\n * advisory lock keyed on the template. Postgres permits only one\n * `CREATE DATABASE ... TEMPLATE t` at a time — a concurrent one fails with\n * SQLSTATE 55006 — so without the lock every file starting at once would race\n * and all but one would fail. The lock funnels them one at a time, each\n * blocking *in Postgres* (not busy-waiting) until its turn. A create that still\n * hits a transient 55006 is retried with backoff.\n *\n * `WITH (FORCE)` ends connections the previous lessee's pool left open: its\n * isolate is gone, so nothing will close them.\n */\nexport async function cloneWorkerDatabase(\n  adminConn: string,\n  dbName: string,\n  template: string,\n): Promise<void> {\n  await withAdminClient(adminConn, async (query) => {\n    const lockKey = quoteLiteral(`stratal:worker-db-clone:${template}`)\n    await query(`SELECT pg_advisory_lock(hashtext(${lockKey}))`)\n    try {\n      await query(`DROP DATABASE IF EXISTS ${quoteIdent(dbName)} WITH (FORCE)`)\n      const create = `CREATE DATABASE ${quoteIdent(dbName)} TEMPLATE ${quoteIdent(template)}`\n      for (let attempt = 1; ; attempt++) {\n        try {\n          await query(create)\n          return\n        } catch (error) {\n          if (isTemplateInUse(error) && attempt < 5) {\n            await sleep(250 * attempt)\n            continue\n          }\n          throw error\n        }\n      }\n    } finally {\n      await query(`SELECT pg_advisory_unlock(hashtext(${lockKey}))`)\n    }\n  })\n}\n\n/** A worker database leased to the current isolate. */\nexport interface WorkerDatabaseLease {\n  /** The leased database's name (`<base>_w_<slot>`). */\n  name: string\n  /** `base` pointed at the leased database. */\n  connectionString: string\n}\n\n/**\n * The connections holding this isolate's leases. A lease is a session-level\n * advisory lock, so it lasts exactly as long as its connection: kept open here\n * for the isolate's lifetime, it closes — and the slot frees — when the pool\n * disposes the isolate at the end of its test file.\n */\nconst leaseConnections: pg.Client[] = []\n\n/**\n * Lease the lowest free worker database for `base` and fill it with a fresh\n * clone of the template.\n *\n * A slot is free when no other session holds its advisory lock. The pool runs\n * each test file in its own isolate and disposes that isolate when the file\n * ends, so a run never holds more slots than it runs files at once — and so\n * never more worker databases. Every lease re-clones, so a file starts from\n * exactly the template, including anything `prepare` baked into it.\n */\nexport async function leaseWorkerDatabase(base: string): Promise<WorkerDatabaseLease> {\n  const pg = await importPg()\n  const adminConn = deriveAdminConnectionString(base)\n  const template = deriveTemplateName(base)\n  const client = new pg.Client({ connectionString: adminConn })\n  await client.connect()\n  try {\n    let slot = 0\n    for (; ; slot++) {\n      const { rows } = await client.query<{ acquired: boolean }>(\n        `SELECT pg_try_advisory_lock(hashtext(${quoteLiteral(leaseLockKey(template, slot))})) AS acquired`,\n      )\n      if (rows[0]?.acquired) break\n    }\n    const name = deriveWorkerDbName(base, slot)\n    await cloneWorkerDatabase(adminConn, name, template)\n    leaseConnections.push(client)\n    return { name, connectionString: buildConnectionString(base, name) }\n  } catch (error) {\n    await client.end().catch(() => {\n      // The lease failed; its connection's close error adds nothing.\n    })\n    throw error\n  }\n}\n\n/**\n * Drop worker databases nobody is using, leaving a concurrent process's live\n * ones intact.\n *\n * Multiple setups can run at once (CI sharding, several e2e projects), so a\n * database is dropped only when it has **no active backend connections** and\n * its lease slot is free. The slot check closes the window between a lease and\n * the lessee's first connection: a just-cloned database has no connections yet\n * but is already spoken for. The sweep takes the slot's lock itself while it\n * drops, so no lease can begin mid-drop.\n */\nasync function sweepStaleDatabases(adminConn: string, prefix: string, template: string): Promise<void> {\n  // Escape both the SQL-string quote and the LIKE metacharacters (`\\`, `%`, `_`)\n  // so a prefix containing `_` (a single-char wildcard) can't over-match and drop\n  // an unrelated database. `\\` is the explicit ESCAPE character below.\n  const likePrefix = prefix\n    .replace(/'/g, \"''\")\n    .replace(/[\\\\%_]/g, (c) => `\\\\${c}`)\n  await withAdminClient(adminConn, async (query) => {\n    const { rows } = (await query(\n      `SELECT d.datname FROM pg_database d ` +\n        `WHERE d.datname LIKE '${likePrefix}%' ESCAPE '\\\\' ` +\n        `AND NOT EXISTS (SELECT 1 FROM pg_stat_activity a WHERE a.datname = d.datname)`,\n    )) as { rows: { datname: string }[] }\n    for (const { datname } of rows) {\n      const slot = slotOfWorkerDb(prefix, datname)\n      if (slot === null) continue\n      const lockKey = quoteLiteral(leaseLockKey(template, slot))\n      const { rows: lock } = (await query(\n        `SELECT pg_try_advisory_lock(hashtext(${lockKey})) AS acquired`,\n      )) as { rows: { acquired: boolean }[] }\n      if (!lock[0]?.acquired) continue\n      try {\n        await query(`DROP DATABASE IF EXISTS ${quoteIdent(datname)} WITH (FORCE)`)\n      } finally {\n        await query(`SELECT pg_advisory_unlock(hashtext(${lockKey}))`)\n      }\n    }\n  })\n}\n\n/**\n * Run `fn` while holding a session-level Postgres advisory lock keyed to\n * `lockKey`, serializing template setup across concurrent processes (CI\n * sharding, multiple e2e projects) so they don't drop/recreate the template out\n * from under each other. The lock is released in `finally`.\n */\nasync function withAdvisoryLock<T>(adminConn: string, lockKey: string, fn: () => Promise<T>): Promise<T> {\n  return withAdminClient(adminConn, async (query) => {\n    await query(`SELECT pg_advisory_lock(hashtext(${quoteLiteral(lockKey)}))`)\n    try {\n      return await fn()\n    } finally {\n      await query(`SELECT pg_advisory_unlock(hashtext(${quoteLiteral(lockKey)}))`)\n    }\n  })\n}\n\n/** Schema source file extensions hashed into the template fingerprint. */\nconst SCHEMA_FILE_RE = /\\.(zmodel|prisma|sql)$/\n\n/** Matches ZModel `import \"...\"` / `import '...'` statements. */\nconst ZMODEL_IMPORT_RE = /^\\s*import\\s+['\"]([^'\"]+)['\"]/gm\n\n/**\n * Follow a ZModel file's `import` graph, collecting the root plus every\n * transitively imported `.zmodel` file — ZenStack supports multi-file schemas,\n * so editing an imported file must invalidate the fingerprint. Import paths\n * resolve relative to the importing file; the `.zmodel` extension is optional.\n * A missing import target is skipped (migration surfaces the real error).\n */\nfunction collectZmodelImports(file: string, seen: Set<string>): void {\n  if (seen.has(file)) return\n  let content: string\n  try {\n    content = readFileSync(file, 'utf8')\n  } catch {\n    return // missing import target — not part of the fingerprint\n  }\n  seen.add(file)\n  for (const [, importPath] of content.matchAll(ZMODEL_IMPORT_RE)) {\n    const target = resolve(dirname(file), importPath)\n    collectZmodelImports(target.endsWith('.zmodel') ? target : `${target}.zmodel`, seen)\n  }\n}\n\n/**\n * Expand a schema path into the concrete files to hash. A directory contributes\n * every schema file in its tree; a single `.zmodel` file contributes its whole\n * `import` graph; any other file contributes itself.\n */\nfunction collectSchemaFiles(path: string): string[] {\n  if (statSync(path).isDirectory()) {\n    const out: string[] = []\n    for (const entry of readdirSync(path, { withFileTypes: true })) {\n      const full = join(path, entry.name)\n      if (entry.isDirectory()) out.push(...collectSchemaFiles(full))\n      else if (SCHEMA_FILE_RE.test(entry.name)) out.push(full)\n    }\n    return out\n  }\n  if (path.endsWith('.zmodel')) {\n    const seen = new Set<string>()\n    collectZmodelImports(path, seen)\n    return [...seen]\n  }\n  return [path]\n}\n\n/**\n * A content-derived fingerprint of the schema source(s) plus the migrate and\n * prepare routines. The template is reused across runs while this is\n * unchanged; any edit to a schema file — or to how migration/preparation run\n * — changes it and forces a rebuild. Uses file basenames (not absolute paths)\n * so it is stable across checkouts.\n *\n * @internal exported for fingerprint unit tests\n */\nexport function computeSchemaFingerprint(\n  schema: string | string[],\n  migrate: TestDatabaseGlobalSetupOptions['migrate'],\n  prepare?: TestDatabaseGlobalSetupOptions['prepare'],\n): string {\n  const roots = Array.isArray(schema) ? schema : [schema]\n  const files = roots.flatMap(collectSchemaFiles).sort()\n  if (files.length === 0) {\n    throw new Error(\n      `[stratal-testing] No schema files found for fingerprinting under: ${roots.join(', ')}`,\n    )\n  }\n  const hash = createHash('sha256')\n  for (const file of files) {\n    hash.update(basename(file))\n    hash.update('\\0')\n    hash.update(readFileSync(file))\n    hash.update('\\0')\n  }\n  hash.update(migrate.toString())\n  hash.update('\\0')\n  hash.update(prepare ? prepare.toString() : '')\n  return hash.digest('hex')\n}\n\n/**\n * Read the template database's stored schema fingerprint (kept as the database\n * COMMENT). Returns `null` when the template does not exist or carries no\n * fingerprint. Database comments are NOT copied by `CREATE DATABASE ...\n * TEMPLATE`, so worker clones never inherit it.\n */\nasync function readTemplateFingerprint(\n  query: (sql: string) => Promise<unknown>,\n  template: string,\n): Promise<string | null> {\n  const { rows } = (await query(\n    `SELECT shobj_description(oid, 'pg_database') AS fingerprint ` +\n      `FROM pg_database WHERE datname = ${quoteLiteral(template)}`,\n  )) as { rows: { fingerprint: string | null }[] }\n  return rows.length === 0 ? null : rows[0].fingerprint\n}\n\n/** Options for {@link createTestDatabaseGlobalSetup}. */\nexport interface TestDatabaseGlobalSetupOptions {\n  /** Run migrations against the template connection string. */\n  migrate: (connectionString: string) => void | Promise<void>\n  /**\n   * Schema source(s) — file or directory path(s). Contents + `migrate` + `prepare`\n   * are hashed into the template fingerprint; the template is reused across runs\n   * while unchanged. For a ZenStack multi-file schema pass the root `.zmodel`.\n   */\n  schema: string | string[]\n  /**\n   * One-time preparation run against the template **after** migrations (before\n   * the fingerprint is stamped). Bake expensive baseline state here — seed data,\n   * a default tenant schema, reference rows — so every worker database inherits\n   * it via the clone instead of rebuilding it per test.\n   *\n   * The fingerprint hashes this hook's **source text only** — if `prepare` reads\n   * external data files (seed JSON/SQL) at runtime, changing only those files\n   * will NOT invalidate the template. Bump the hook's source (e.g. a version\n   * comment) or drop the template manually when seed data changes.\n   */\n  prepare?: (connectionString: string) => void | Promise<void>\n  /** Base/admin connection string. Defaults to `process.env.DATABASE_URL`. */\n  connectionString?: string\n  /** Template database name. Defaults to `<baseDbName>_template`. */\n  templateName?: string\n}\n\n/**\n * Build a Vitest `globalSetup` default export that prepares the test database.\n *\n * Under a Postgres advisory lock (so concurrent setups across CI shards /\n * multiple e2e projects don't clobber each other), sweeps unused worker\n * databases, then ensures a migrated (and optionally prepared) template exists\n * — ready to be cloned into each leased worker database.\n *\n * **Template reuse.** The template is fingerprinted from the `schema` source(s)\n * + the `migrate` routine + the `prepare` routine, and the fingerprint is\n * stored as the template's database COMMENT. On each run, a matching\n * fingerprint means nothing has changed and the existing template is reused\n * as-is — `migrate`/`prepare` run **only** on the first run after an edit (or on\n * a fresh database). The fingerprint is stamped only after a successful\n * migrate + prepare, so a match always implies a complete template; there is no\n * force/skip flag — reuse is purely fingerprint-driven.\n *\n * **Concurrency model.** The reuse check + rebuild runs under\n * `pg_advisory_lock(hashtext(<template>))`, so only one process rebuilds the\n * template at a time. The sweep only drops worker databases with **no active\n * connections** and a free lease slot, leaving a sibling process's live databases\n * intact — which is what lets it run at teardown as well as at setup, so a run\n * takes its own databases with it. Teardown deliberately does **not** drop the\n * template: it is shared, and the next run reuses it by fingerprint.\n *\n * @example\n * ```ts\n * // test/global-setup.ts\n * import { createTestDatabaseGlobalSetup } from '@stratal/testing/database'\n *\n * export default createTestDatabaseGlobalSetup({\n *   schema: schemaPath, // file or directory — reused-when-unchanged fingerprint\n *   migrate: (conn) => execFileSync(zenstackBin, ['db', 'push', '--force-reset', `--schema=${schemaPath}`, '--accept-data-loss'],\n *     { env: { ...process.env, DATABASE_URL: conn }, stdio: 'inherit' }),\n * })\n * ```\n */\nexport function createTestDatabaseGlobalSetup(\n  opts: TestDatabaseGlobalSetupOptions,\n): () => Promise<() => Promise<void>> {\n  return async () => {\n    const base = opts.connectionString ?? process.env.DATABASE_URL\n    if (!base) {\n      throw new Error(\n        '[stratal-testing] No connection string for test database setup. Set process.env.DATABASE_URL or pass `connectionString`.',\n      )\n    }\n\n    const adminConn = deriveAdminConnectionString(base)\n    const template = opts.templateName ?? deriveTemplateName(base)\n    const prefix = databasePrefix(base)\n    // Leases are keyed on the derived template name, so the sweep checks the same keys.\n    const leaseTemplate = deriveTemplateName(base)\n    const fingerprint = computeSchemaFingerprint(opts.schema, opts.migrate, opts.prepare)\n\n    // Serialize template rebuild across concurrent setups so they don't drop or\n    // migrate the template out from under each other.\n    await withAdvisoryLock(adminConn, template, async () => {\n      await sweepStaleDatabases(adminConn, prefix, leaseTemplate)\n\n      // Reuse the existing template when its stored fingerprint matches — the\n      // schema is unchanged, so the migrated template is ready to clone. Only a\n      // fingerprint mismatch (or a missing template) pays the migration cost.\n      const current = await withAdminClient(adminConn, (query) =>\n        readTemplateFingerprint(query, template),\n      )\n      if (current === fingerprint) return\n\n      await withAdminClient(adminConn, async (query) => {\n        await query(`DROP DATABASE IF EXISTS ${quoteIdent(template)} WITH (FORCE)`)\n        await query(`CREATE DATABASE ${quoteIdent(template)}`)\n      })\n      const templateConn = buildConnectionString(base, template)\n      await opts.migrate(templateConn)\n      if (opts.prepare) await opts.prepare(templateConn)\n      // Stamp the fingerprint only after a successful migrate + prepare, so a\n      // matching fingerprint always implies a complete, ready template. Database\n      // COMMENTs are not copied by CREATE DATABASE ... TEMPLATE, so clones stay\n      // clean.\n      await withAdminClient(adminConn, (query) =>\n        query(`COMMENT ON DATABASE ${quoteIdent(template)} IS ${quoteLiteral(fingerprint)}`),\n      )\n    })\n\n    // The run reclaims its own worker databases as it ends.\n    //\n    // The sweep matches on the base database's name, so the only process that\n    // ever sees these databases is one configured with that same name. Nothing\n    // else will reach them, which is why the sweep belongs here as well as at\n    // setup — and why a pile of them is otherwise bounded by nothing.\n    //\n    // Connection- and lease-guarded, which is what makes it safe here: by now\n    // this run's files have finished and hold neither, while a concurrent\n    // process's databases are still leased and are skipped. The template is\n    // shared and reused by fingerprint, so it stays.\n    //\n    // Once per run, not once per file: the drop is trivial, but reaching the\n    // maintenance database to issue it is not, and a per-file hook pays that\n    // connection on every spec file.\n    return async () => {\n      await sweepStaleDatabases(adminConn, prefix, leaseTemplate)\n    }\n  }\n}\n","import type pg from 'pg'\n\n/** Options controlling which tables a per-test reset truncates. */\nexport interface ResetOptions {\n  /** Extra schemas to include beyond `current_schema()` (e.g. a tenant schema). */\n  schemas?: string[]\n  /**\n   * Bare table names or SQL LIKE patterns (matched against `tablename` across\n   * all target schemas) that must survive the reset — reference/seed data baked\n   * into the template. Not schema-qualified: a `schema.table` entry matches a\n   * table literally named `schema.table`, not `table` in `schema`. Migration\n   * bookkeeping (`_prisma%`) is always preserved.\n   */\n  preserve?: string[]\n}\n\nfunction quoteIdent(ident: string): string {\n  return `\"${ident.replace(/\"/g, '\"\"')}\"`\n}\n\n/**\n * Build a single `TRUNCATE ... RESTART IDENTITY CASCADE` (empty when no tables).\n * Takes `{ schema, table }` pairs and quotes each part independently, so a\n * dotted identifier (a legal quoted name, e.g. `\"my.table\"`) is preserved\n * verbatim rather than mis-split into extra qualifier segments.\n */\nexport function buildTruncateSql(tables: { schema: string; table: string }[]): string {\n  if (tables.length === 0) return ''\n  const quoted = tables.map((t) => `${quoteIdent(t.schema)}.${quoteIdent(t.table)}`)\n  return `TRUNCATE ${quoted.join(', ')} RESTART IDENTITY CASCADE`\n}\n\n/**\n * Sentinel meaning \"the active search-path schema\" (`current_schema()`). A\n * Symbol so it can never collide with a real schema name — a schema literally\n * named `current` is passed through as the string literal `'current'`.\n */\nconst CURRENT_SCHEMA = Symbol('current_schema')\n\n/**\n * Build the SQL that discovers truncatable tables: every base table in the\n * given schemas ({@link CURRENT_SCHEMA} → `current_schema()`), excluding\n * migration bookkeeping (`_prisma%`) and any caller-supplied preserve patterns.\n * Returns a SELECT of `schemaname, tablename`. Escaping lives here so both reset\n * paths share one implementation.\n */\nexport function buildTableDiscoverySql(schemas: string[], preserve: string[]): string {\n  const schemaFilter = [CURRENT_SCHEMA, ...schemas]\n    .map((s) => (typeof s === 'symbol' ? 'current_schema()' : `'${s.replace(/'/g, \"''\")}'`))\n    .join(', ')\n  const notLike = ['_prisma%', ...preserve]\n    .map((p) => `tablename NOT LIKE '${p.replace(/'/g, \"''\")}'`)\n    .join(' AND ')\n  return `SELECT schemaname::text AS schemaname, tablename::text AS tablename FROM pg_tables WHERE schemaname IN (${schemaFilter}) AND ${notLike}`\n}\n\nasync function importPg(): Promise<typeof pg> {\n  const { default: mod } = await import('pg')\n  return mod\n}\n\n/**\n * Reset a worker database between tests: discover every non-preserved table in\n * the target schemas and truncate them in one statement. Fast because the\n * schema/DDL is baked into the worker DB — reset only clears mutable rows and\n * resets identities. Opens and closes a short-lived direct `pg` connection.\n */\nexport async function resetWorkerDatabase(connectionString: string, opts: ResetOptions = {}): Promise<void> {\n  const pgMod = await importPg()\n  const client = new pgMod.Client({ connectionString })\n  await client.connect()\n  try {\n    const sql = buildTableDiscoverySql(opts.schemas ?? [], opts.preserve ?? [])\n    const { rows } = await client.query<{ schemaname: string; tablename: string }>(sql)\n    const tables = rows.map((r) => ({ schema: r.schemaname, table: r.tablename }))\n    const truncateSql = buildTruncateSql(tables)\n    if (truncateSql) await client.query(truncateSql)\n  } finally {\n    await client.end()\n  }\n}\n"],"mappings":"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"}

package/dist/{decorate-B7nr7eBl.mjs → decorate-RQD1h28J.mjs}

@@ -1,4 +1,4 @@
-//#region \0@oxc-project+runtime@0.133.0/helpers/esm/decorate.js
+//#region \0@oxc-project+runtime@0.150.0/helpers/esm/decorate.js
 function __decorate(decorators, target, key, desc) {
 	var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
 	if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);

package/dist/feature-flags/index.mjs

@@ -1,2 +1,2 @@
-import { n as FakeFeatureFlagService, t as FEATURE_FLAG_SERVICE_TOKEN } from "../feature-flags-BiLhfSGh.mjs";
+import { n as FakeFeatureFlagService, t as FEATURE_FLAG_SERVICE_TOKEN } from "../feature-flags-CZ1a4M2g.mjs";
 export { FEATURE_FLAG_SERVICE_TOKEN, FakeFeatureFlagService };

package/dist/{feature-flags-BiLhfSGh.mjs → feature-flags-CZ1a4M2g.mjs}

@@ -1,4 +1,4 @@
-import { t as __decorate } from "./decorate-B7nr7eBl.mjs";
+import { t as __decorate } from "./decorate-RQD1h28J.mjs";
 import { Singleton } from "stratal/di";
 //#region src/feature-flags/fake-feature-flag.service.ts
 /**
@@ -83,4 +83,4 @@ FakeFeatureFlagService = __decorate([Singleton(FEATURE_FLAG_SERVICE_TOKEN)], Fak
 //#endregion
 export { FakeFeatureFlagService as n, FEATURE_FLAG_SERVICE_TOKEN as t };
 
-//# sourceMappingURL=feature-flags-BiLhfSGh.mjs.map
+//# sourceMappingURL=feature-flags-CZ1a4M2g.mjs.map

package/dist/{feature-flags-BiLhfSGh.mjs.map → feature-flags-CZ1a4M2g.mjs.map}

@@ -1 +1 @@
-{"version":3,"file":"feature-flags-BiLhfSGh.mjs","names":[],"sources":["../src/feature-flags/fake-feature-flag.service.ts"],"sourcesContent":["import { Singleton } from 'stratal/di';\n\n/**\n * Global DI token for the feature-flags service.\n *\n * Mirrors `FEATURE_FLAG_TOKENS.FeatureFlagService` from `@stratal/feature-flags`\n * — `Symbol.for(...)` resolves to the same symbol across packages via the global\n * registry. Declared here so `@stratal/testing` needs no dependency on the\n * optional feature-flags package. Keep this string in sync with\n * `packages/feature-flags/src/feature-flags.tokens.ts`.\n */\nexport const FEATURE_FLAG_SERVICE_TOKEN = Symbol.for('stratal:feature-flags:service')\n\n/** A value a feature flag can resolve to. */\nexport type FlagValue = boolean | string | number | object\n\ninterface FakeFlagDetails<T> {\n  flagKey: string\n  value: T\n  reason: string\n}\n\n/**\n * FakeFeatureFlagService\n *\n * In-memory stand-in for `@stratal/feature-flags`'s request-scoped\n * `FeatureFlagService`, auto-registered by the testing module so feature-gated\n * code resolves without a real Cloudflare Flagship binding (which only exists at\n * runtime). Mirrors the real service's public evaluation surface.\n *\n * Unset flags return the per-call default (or the type's zero value). Configure\n * values with {@link set} / {@link setAll}; access it in tests via\n * `module.featureFlags`.\n *\n * @example\n * ```typescript\n * module.featureFlags.set('new-checkout', true)\n * const enabled = await flags.getBooleanValue('new-checkout') // true\n * ```\n */\n@Singleton(FEATURE_FLAG_SERVICE_TOKEN)\nexport class FakeFeatureFlagService {\n  private readonly flags = new Map<string, FlagValue>()\n\n  // ==================== CONFIGURATION ====================\n\n  /** Set a single flag value. */\n  set(flagKey: string, value: FlagValue): this {\n    this.flags.set(flagKey, value)\n    return this\n  }\n\n  /** Replace all configured flags with the given map. */\n  setAll(flags: Record<string, FlagValue>): this {\n    this.reset()\n    for (const [key, value] of Object.entries(flags)) this.flags.set(key, value)\n    return this\n  }\n\n  /** Clear every configured flag. */\n  reset(): this {\n    this.flags.clear()\n    return this\n  }\n\n  // ==================== EVALUATION ====================\n\n  async get(flagKey: string, defaultValue?: unknown): Promise<unknown> {\n    return Promise.resolve(this.flags.has(flagKey) ? this.flags.get(flagKey) : defaultValue)\n  }\n\n  async getBooleanValue(flagKey: string, defaultValue = false): Promise<boolean> {\n    return this.resolve(flagKey, defaultValue)\n  }\n\n  async getStringValue(flagKey: string, defaultValue = ''): Promise<string> {\n    return this.resolve(flagKey, defaultValue)\n  }\n\n  async getNumberValue(flagKey: string, defaultValue = 0): Promise<number> {\n    return this.resolve(flagKey, defaultValue)\n  }\n\n  async getObjectValue<T extends object>(flagKey: string, defaultValue: T = {} as T): Promise<T> {\n    return this.resolve(flagKey, defaultValue)\n  }\n\n  async getBooleanDetails(flagKey: string, defaultValue = false): Promise<FakeFlagDetails<boolean>> {\n    return this.details(flagKey, await this.getBooleanValue(flagKey, defaultValue))\n  }\n\n  async getStringDetails(flagKey: string, defaultValue = ''): Promise<FakeFlagDetails<string>> {\n    return this.details(flagKey, await this.getStringValue(flagKey, defaultValue))\n  }\n\n  async getNumberDetails(flagKey: string, defaultValue = 0): Promise<FakeFlagDetails<number>> {\n    return this.details(flagKey, await this.getNumberValue(flagKey, defaultValue))\n  }\n\n  async getObjectDetails<T extends object>(flagKey: string, defaultValue: T = {} as T): Promise<FakeFlagDetails<T>> {\n    return this.details(flagKey, await this.getObjectValue(flagKey, defaultValue))\n  }\n\n  /** Returns every configured flag as a `{ key: value }` map. */\n  async all(): Promise<Record<string, FlagValue>> {\n    return Promise.resolve(Object.fromEntries(this.flags))\n  }\n\n  /** Switching Flagship apps is a no-op in the fake. */\n  use(): this {\n    return this\n  }\n\n  /** The binding name this instance targets. */\n  // oxlint-disable-next-line typescript/class-literal-property-style\n  get app(): string {\n    return 'fake'\n  }\n\n  // ==================== INTERNAL ====================\n\n  private resolve<T extends FlagValue>(flagKey: string, defaultValue: T): Promise<T> {\n    return Promise.resolve(this.flags.has(flagKey) ? (this.flags.get(flagKey) as T) : defaultValue)\n  }\n\n  private details<T>(flagKey: string, value: T): FakeFlagDetails<T> {\n    return { flagKey, value, reason: 'fake' }\n  }\n}\n"],"mappings":";;;;;;;;;;;;AAWA,MAAa,6BAA6B,OAAO,IAAI,+BAA+B;AA8B7E,IAAA,yBAAA,MAAM,uBAAuB;CAClC,wBAAyB,IAAI,IAAuB;;CAKpD,IAAI,SAAiB,OAAwB;EAC3C,KAAK,MAAM,IAAI,SAAS,KAAK;EAC7B,OAAO;CACT;;CAGA,OAAO,OAAwC;EAC7C,KAAK,MAAM;EACX,KAAK,MAAM,CAAC,KAAK,UAAU,OAAO,QAAQ,KAAK,GAAG,KAAK,MAAM,IAAI,KAAK,KAAK;EAC3E,OAAO;CACT;;CAGA,QAAc;EACZ,KAAK,MAAM,MAAM;EACjB,OAAO;CACT;CAIA,MAAM,IAAI,SAAiB,cAA0C;EACnE,OAAO,QAAQ,QAAQ,KAAK,MAAM,IAAI,OAAO,IAAI,KAAK,MAAM,IAAI,OAAO,IAAI,YAAY;CACzF;CAEA,MAAM,gBAAgB,SAAiB,eAAe,OAAyB;EAC7E,OAAO,KAAK,QAAQ,SAAS,YAAY;CAC3C;CAEA,MAAM,eAAe,SAAiB,eAAe,IAAqB;EACxE,OAAO,KAAK,QAAQ,SAAS,YAAY;CAC3C;CAEA,MAAM,eAAe,SAAiB,eAAe,GAAoB;EACvE,OAAO,KAAK,QAAQ,SAAS,YAAY;CAC3C;CAEA,MAAM,eAAiC,SAAiB,eAAkB,CAAC,GAAoB;EAC7F,OAAO,KAAK,QAAQ,SAAS,YAAY;CAC3C;CAEA,MAAM,kBAAkB,SAAiB,eAAe,OAA0C;EAChG,OAAO,KAAK,QAAQ,SAAS,MAAM,KAAK,gBAAgB,SAAS,YAAY,CAAC;CAChF;CAEA,MAAM,iBAAiB,SAAiB,eAAe,IAAsC;EAC3F,OAAO,KAAK,QAAQ,SAAS,MAAM,KAAK,eAAe,SAAS,YAAY,CAAC;CAC/E;CAEA,MAAM,iBAAiB,SAAiB,eAAe,GAAqC;EAC1F,OAAO,KAAK,QAAQ,SAAS,MAAM,KAAK,eAAe,SAAS,YAAY,CAAC;CAC/E;CAEA,MAAM,iBAAmC,SAAiB,eAAkB,CAAC,GAAqC;EAChH,OAAO,KAAK,QAAQ,SAAS,MAAM,KAAK,eAAe,SAAS,YAAY,CAAC;CAC/E;;CAGA,MAAM,MAA0C;EAC9C,OAAO,QAAQ,QAAQ,OAAO,YAAY,KAAK,KAAK,CAAC;CACvD;;CAGA,MAAY;EACV,OAAO;CACT;;CAIA,IAAI,MAAc;EAChB,OAAO;CACT;CAIA,QAAqC,SAAiB,cAA6B;EACjF,OAAO,QAAQ,QAAQ,KAAK,MAAM,IAAI,OAAO,IAAK,KAAK,MAAM,IAAI,OAAO,IAAU,YAAY;CAChG;CAEA,QAAmB,SAAiB,OAA8B;EAChE,OAAO;GAAE;GAAS;GAAO,QAAQ;EAAO;CAC1C;AACF;qCAxFC,UAAU,0BAA0B,CAAA,GAAA,sBAAA"}
+{"version":3,"file":"feature-flags-CZ1a4M2g.mjs","names":[],"sources":["../src/feature-flags/fake-feature-flag.service.ts"],"sourcesContent":["import { Singleton } from 'stratal/di';\n\n/**\n * Global DI token for the feature-flags service.\n *\n * Mirrors `FEATURE_FLAG_TOKENS.FeatureFlagService` from `@stratal/feature-flags`\n * — `Symbol.for(...)` resolves to the same symbol across packages via the global\n * registry. Declared here so `@stratal/testing` needs no dependency on the\n * optional feature-flags package. Keep this string in sync with\n * `packages/feature-flags/src/feature-flags.tokens.ts`.\n */\nexport const FEATURE_FLAG_SERVICE_TOKEN = Symbol.for('stratal:feature-flags:service')\n\n/** A value a feature flag can resolve to. */\nexport type FlagValue = boolean | string | number | object\n\ninterface FakeFlagDetails<T> {\n  flagKey: string\n  value: T\n  reason: string\n}\n\n/**\n * FakeFeatureFlagService\n *\n * In-memory stand-in for `@stratal/feature-flags`'s request-scoped\n * `FeatureFlagService`, auto-registered by the testing module so feature-gated\n * code resolves without a real Cloudflare Flagship binding (which only exists at\n * runtime). Mirrors the real service's public evaluation surface.\n *\n * Unset flags return the per-call default (or the type's zero value). Configure\n * values with {@link set} / {@link setAll}; access it in tests via\n * `module.featureFlags`.\n *\n * @example\n * ```typescript\n * module.featureFlags.set('new-checkout', true)\n * const enabled = await flags.getBooleanValue('new-checkout') // true\n * ```\n */\n@Singleton(FEATURE_FLAG_SERVICE_TOKEN)\nexport class FakeFeatureFlagService {\n  private readonly flags = new Map<string, FlagValue>()\n\n  // ==================== CONFIGURATION ====================\n\n  /** Set a single flag value. */\n  set(flagKey: string, value: FlagValue): this {\n    this.flags.set(flagKey, value)\n    return this\n  }\n\n  /** Replace all configured flags with the given map. */\n  setAll(flags: Record<string, FlagValue>): this {\n    this.reset()\n    for (const [key, value] of Object.entries(flags)) this.flags.set(key, value)\n    return this\n  }\n\n  /** Clear every configured flag. */\n  reset(): this {\n    this.flags.clear()\n    return this\n  }\n\n  // ==================== EVALUATION ====================\n\n  async get(flagKey: string, defaultValue?: unknown): Promise<unknown> {\n    return Promise.resolve(this.flags.has(flagKey) ? this.flags.get(flagKey) : defaultValue)\n  }\n\n  async getBooleanValue(flagKey: string, defaultValue = false): Promise<boolean> {\n    return this.resolve(flagKey, defaultValue)\n  }\n\n  async getStringValue(flagKey: string, defaultValue = ''): Promise<string> {\n    return this.resolve(flagKey, defaultValue)\n  }\n\n  async getNumberValue(flagKey: string, defaultValue = 0): Promise<number> {\n    return this.resolve(flagKey, defaultValue)\n  }\n\n  async getObjectValue<T extends object>(flagKey: string, defaultValue: T = {} as T): Promise<T> {\n    return this.resolve(flagKey, defaultValue)\n  }\n\n  async getBooleanDetails(flagKey: string, defaultValue = false): Promise<FakeFlagDetails<boolean>> {\n    return this.details(flagKey, await this.getBooleanValue(flagKey, defaultValue))\n  }\n\n  async getStringDetails(flagKey: string, defaultValue = ''): Promise<FakeFlagDetails<string>> {\n    return this.details(flagKey, await this.getStringValue(flagKey, defaultValue))\n  }\n\n  async getNumberDetails(flagKey: string, defaultValue = 0): Promise<FakeFlagDetails<number>> {\n    return this.details(flagKey, await this.getNumberValue(flagKey, defaultValue))\n  }\n\n  async getObjectDetails<T extends object>(flagKey: string, defaultValue: T = {} as T): Promise<FakeFlagDetails<T>> {\n    return this.details(flagKey, await this.getObjectValue(flagKey, defaultValue))\n  }\n\n  /** Returns every configured flag as a `{ key: value }` map. */\n  async all(): Promise<Record<string, FlagValue>> {\n    return Promise.resolve(Object.fromEntries(this.flags))\n  }\n\n  /** Switching Flagship apps is a no-op in the fake. */\n  use(): this {\n    return this\n  }\n\n  /** The binding name this instance targets. */\n  // oxlint-disable-next-line typescript/class-literal-property-style\n  get app(): string {\n    return 'fake'\n  }\n\n  // ==================== INTERNAL ====================\n\n  private resolve<T extends FlagValue>(flagKey: string, defaultValue: T): Promise<T> {\n    return Promise.resolve(this.flags.has(flagKey) ? (this.flags.get(flagKey) as T) : defaultValue)\n  }\n\n  private details<T>(flagKey: string, value: T): FakeFlagDetails<T> {\n    return { flagKey, value, reason: 'fake' }\n  }\n}\n"],"mappings":";;;;;;;;;;;;AAWA,MAAa,6BAA6B,OAAO,IAAI,+BAA+B;AA8B7E,IAAM,yBAAN,MAAM,uBAAuB;CAClC,wBAAyB,IAAI,IAAuB;;CAKpD,IAAI,SAAiB,OAAwB;EAC3C,KAAK,MAAM,IAAI,SAAS,KAAK;EAC7B,OAAO;CACT;;CAGA,OAAO,OAAwC;EAC7C,KAAK,MAAM;EACX,KAAK,MAAM,CAAC,KAAK,UAAU,OAAO,QAAQ,KAAK,GAAG,KAAK,MAAM,IAAI,KAAK,KAAK;EAC3E,OAAO;CACT;;CAGA,QAAc;EACZ,KAAK,MAAM,MAAM;EACjB,OAAO;CACT;CAIA,MAAM,IAAI,SAAiB,cAA0C;EACnE,OAAO,QAAQ,QAAQ,KAAK,MAAM,IAAI,OAAO,IAAI,KAAK,MAAM,IAAI,OAAO,IAAI,YAAY;CACzF;CAEA,MAAM,gBAAgB,SAAiB,eAAe,OAAyB;EAC7E,OAAO,KAAK,QAAQ,SAAS,YAAY;CAC3C;CAEA,MAAM,eAAe,SAAiB,eAAe,IAAqB;EACxE,OAAO,KAAK,QAAQ,SAAS,YAAY;CAC3C;CAEA,MAAM,eAAe,SAAiB,eAAe,GAAoB;EACvE,OAAO,KAAK,QAAQ,SAAS,YAAY;CAC3C;CAEA,MAAM,eAAiC,SAAiB,eAAkB,CAAC,GAAoB;EAC7F,OAAO,KAAK,QAAQ,SAAS,YAAY;CAC3C;CAEA,MAAM,kBAAkB,SAAiB,eAAe,OAA0C;EAChG,OAAO,KAAK,QAAQ,SAAS,MAAM,KAAK,gBAAgB,SAAS,YAAY,CAAC;CAChF;CAEA,MAAM,iBAAiB,SAAiB,eAAe,IAAsC;EAC3F,OAAO,KAAK,QAAQ,SAAS,MAAM,KAAK,eAAe,SAAS,YAAY,CAAC;CAC/E;CAEA,MAAM,iBAAiB,SAAiB,eAAe,GAAqC;EAC1F,OAAO,KAAK,QAAQ,SAAS,MAAM,KAAK,eAAe,SAAS,YAAY,CAAC;CAC/E;CAEA,MAAM,iBAAmC,SAAiB,eAAkB,CAAC,GAAqC;EAChH,OAAO,KAAK,QAAQ,SAAS,MAAM,KAAK,eAAe,SAAS,YAAY,CAAC;CAC/E;;CAGA,MAAM,MAA0C;EAC9C,OAAO,QAAQ,QAAQ,OAAO,YAAY,KAAK,KAAK,CAAC;CACvD;;CAGA,MAAY;EACV,OAAO;CACT;;CAIA,IAAI,MAAc;EAChB,OAAO;CACT;CAIA,QAAqC,SAAiB,cAA6B;EACjF,OAAO,QAAQ,QAAQ,KAAK,MAAM,IAAI,OAAO,IAAK,KAAK,MAAM,IAAI,OAAO,IAAU,YAAY;CAChG;CAEA,QAAmB,SAAiB,OAA8B;EAChE,OAAO;GAAE;GAAS;GAAO,QAAQ;EAAO;CAC1C;AACF;AAxFC,yBAAA,WAAA,CAAA,UAAU,0BAA0B,CAAA,GAAA,sBAAA"}