@stratal/testing 0.0.27 → 0.1.1

package/dist/index.mjs

@@ -1,11 +1,12 @@
-import { a as createDatabaseFromTemplate, c as deriveAdminConnectionString, d as dropDatabase, f as normalizeIsolation, i as buildConnectionString, l as deriveDbName, u as deriveTemplateName } from "./database-B02eYKhE.mjs";
-import { t as FakeStorageService } from "./storage-DhoxWqyF.mjs";
-import { t as __decorate } from "./decorate-B7nr7eBl.mjs";
+import { i as BINDING_ENV_VAR, n as buildTruncateSql, p as leaseWorkerDatabase, t as buildTableDiscoverySql } from "./database-Rojs69r3.mjs";
+import { t as FakeStorageService } from "./storage-BiGamMA8.mjs";
+import { t as __decorate } from "./decorate-RQD1h28J.mjs";
 import { NoopRateLimiterStore } from "./mocks/noop-rate-limiter-store.mjs";
-import { t as TestEmailProvider } from "./test-email-provider-Dr-nhE0x.mjs";
-import { n as FakeFeatureFlagService, t as FEATURE_FLAG_SERVICE_TOKEN } from "./feature-flags-BiLhfSGh.mjs";
+import { n as TestWorkerExports, r as TestEmailProvider, t as TestWorkersCache } from "./test-workers-cache-D02Pt_dE.mjs";
+import { n as FakeFeatureFlagService, t as FEATURE_FLAG_SERVICE_TOKEN } from "./feature-flags-CZ1a4M2g.mjs";
 import { Application } from "stratal";
 import { LogLevel } from "stratal/logger";
+import { markGatewayMode } from "stratal/response-cache";
 import { Module } from "stratal/module";
 import { EMAIL_TOKENS } from "stratal/email";
 import { RATE_LIMITER_TOKENS } from "stratal/rate-limiter";
@@ -117,6 +118,32 @@ var ProviderOverrideBuilder = class {
 	}
 };
 //#endregion
+//#region src/errors/test-error.ts
+/**
+* Base error class for all test framework errors.
+* Extends from Error and allows easy identification via `instanceof`.
+*/
+var TestError = class extends Error {
+	cause;
+	constructor(message, cause) {
+		super(message);
+		this.cause = cause;
+		this.name = "TestError";
+		Error.captureStackTrace(this, this.constructor);
+	}
+};
+//#endregion
+//#region src/errors/setup-error.ts
+/**
+* Error thrown when test setup fails.
+* Examples: schema creation failure, migration failure, application bootstrap failure.
+*/
+var TestSetupError = class extends TestError {
+	constructor(message, cause) {
+		super(`Test setup failed: ${message}`, cause);
+	}
+};
+//#endregion
 //#region src/core/http/locale-helper.ts
 /**
 * Resolve the configured detection strategy from the testing module's DI container.
@@ -139,9 +166,7 @@ function applyLocaleToHeaders(headers, locale, strategy) {
 		case "cookie":
 			headers.set("Cookie", `locale=${locale}`);
 			break;
-		case "header":
-			headers.set("Accept-Language", locale);
-			break;
+		case "header": headers.set("Accept-Language", locale);
 	}
 }
 /**
@@ -400,7 +425,8 @@ var TestResponse = class extends Macroable {
 	* @param path - Dot-notation path (e.g., 'data.user.id')
 	*/
 	async assertJsonPathExists(path) {
-		expect(hasValueAtPath(await this.json(), path), `Expected JSON path "${path}" to exist`).toBe(true);
+		const exists = hasValueAtPath(await this.json(), path);
+		expect(exists, `Expected JSON path "${path}" to exist`).toBe(true);
 		return this;
 	}
 	/**
@@ -409,7 +435,8 @@ var TestResponse = class extends Macroable {
 	* @param path - Dot-notation path (e.g., 'data.user.deletedAt')
 	*/
 	async assertJsonPathMissing(path) {
-		expect(hasValueAtPath(await this.json(), path), `Expected JSON path "${path}" to not exist`).toBe(false);
+		const exists = hasValueAtPath(await this.json(), path);
+		expect(exists, `Expected JSON path "${path}" to not exist`).toBe(false);
 		return this;
 	}
 	/**
@@ -750,19 +777,23 @@ var TestCommandResult = class {
 		return this;
 	}
 	assertOutputContains(text) {
-		expect(this.result.output.join("\n"), `Expected output to contain "${text}"`).toContain(text);
+		const joined = this.result.output.join("\n");
+		expect(joined, `Expected output to contain "${text}"`).toContain(text);
 		return this;
 	}
 	assertOutputMissing(text) {
-		expect(this.result.output.join("\n"), `Expected output NOT to contain "${text}"`).not.toContain(text);
+		const joined = this.result.output.join("\n");
+		expect(joined, `Expected output NOT to contain "${text}"`).not.toContain(text);
 		return this;
 	}
 	assertErrorContains(text) {
-		expect(this.result.errors.join("\n"), `Expected errors to contain "${text}"`).toContain(text);
+		const joined = this.result.errors.join("\n");
+		expect(joined, `Expected errors to contain "${text}"`).toContain(text);
 		return this;
 	}
 	assertErrorMissing(text) {
-		expect(this.result.errors.join("\n"), `Expected errors NOT to contain "${text}"`).not.toContain(text);
+		const joined = this.result.errors.join("\n");
+		expect(joined, `Expected errors NOT to contain "${text}"`).not.toContain(text);
 		return this;
 	}
 };
@@ -896,7 +927,8 @@ var TestSseConnection = class {
 	* Assert that the next event matches the expected partial shape
 	*/
 	async assertEvent(expected, timeout = 5e3) {
-		expect(await this.waitForEvent(timeout)).toMatchObject(expected);
+		const event = await this.waitForEvent(timeout);
+		expect(event).toMatchObject(expected);
 	}
 	/**
 	* Assert that the next event's data matches the expected string
@@ -910,7 +942,8 @@ var TestSseConnection = class {
 	*/
 	async assertJsonEventData(expected, timeout = 5e3) {
 		const event = await this.waitForEvent(timeout);
-		expect(JSON.parse(event.data)).toEqual(expected);
+		const parsed = JSON.parse(event.data);
+		expect(parsed).toEqual(expected);
 	}
 	/**
 	* Access the raw Response
@@ -1262,20 +1295,53 @@ var TestWsRequest = class {
 };
 //#endregion
 //#region src/core/testing-module.ts
+/**
+* TestingModule
+*
+* Provides access to the test application, container, HTTP client, and utilities.
+*
+* @example
+* ```typescript
+* const module = await Test.createTestingModule({
+*   modules: [RegistrationModule],
+* }).compile()
+*
+* // Make HTTP requests
+* const response = await module.http
+*   .post('/api/v1/register')
+*   .withBody({ ... })
+*   .send()
+*
+* // Access services
+* const service = module.get(REGISTRATION_TOKENS.RegistrationService)
+*
+* // Database utilities
+* await module.truncateDb()
+* await module.seed(UserSeeder)
+* await module.assertDatabaseHas('user', { email: 'test@example.com' })
+*
+* // Cleanup
+* await module.close()
+* ```
+*/
 var TestingModule = class {
 	app;
 	env;
 	ctx;
-	isolatedDatabase;
 	testEmailProvider;
+	pendingTasks;
+	testWorkersCache;
+	testWorkerExports;
 	_http = null;
 	_requestContainer;
-	constructor(app, env, ctx, isolatedDatabase = null, testEmailProvider = null) {
+	constructor(app, env, ctx, testEmailProvider = null, pendingTasks = [], testWorkersCache = void 0, testWorkerExports = void 0) {
 		this.app = app;
 		this.env = env;
 		this.ctx = ctx;
-		this.isolatedDatabase = isolatedDatabase;
 		this.testEmailProvider = testEmailProvider;
+		this.pendingTasks = pendingTasks;
+		this.testWorkersCache = testWorkersCache;
+		this.testWorkerExports = testWorkerExports;
 		const mockContext = this.app.createMockRouterContext();
 		this._requestContainer = this.app.container.createRequestScope(mockContext);
 	}
@@ -1301,12 +1367,18 @@ var TestingModule = class {
 	}
 	/**
 	* Get Inertia test client for making Inertia requests
+	*
+	* Sends no `X-Inertia-Version`. It used to send `'1'`, which meant any app configuring a real
+	* asset version had every request from this client read as a stale client and answered with a
+	* version-mismatch 409 — an entire Inertia suite failing on a value the tests never chose. The
+	* check needs a version from BOTH sides, so omitting it here leaves the app under test in charge
+	* rather than this header.
+	*
+	* A test that wants the mismatch path asks for it:
+	* `module.inertia.withHeaders({ 'X-Inertia-Version': 'stale' })`.
 	*/
 	get inertia() {
-		return this.http.withHeaders({
-			"X-Inertia": "true",
-			"X-Inertia-Version": "1"
-		});
+		return this.http.withHeaders({ "X-Inertia": "true" });
 	}
 	/**
 	* Get fake storage service for assertions
@@ -1322,6 +1394,36 @@ var TestingModule = class {
 		return this.get(FEATURE_FLAG_SERVICE_TOKEN);
 	}
 	/**
+	* The default `ctx.cache` stub — present unless this module was compiled
+	* with `cache: false`. Assert `@PurgesCache` routes purged what they should
+	* via `module.cache.purges`, in call order.
+	*
+	* @throws {TestSetupError} This module was compiled with `cache: false`,
+	*   so there is no stub to inspect.
+	*/
+	get cache() {
+		if (!this.testWorkersCache) throw new TestSetupError("module.cache is unavailable because this module was compiled with `cache: false`. Remove that option to use the default ctx.cache stub.");
+		return this.testWorkersCache;
+	}
+	/**
+	* The default `ctx.exports` stub — present unless this module was compiled
+	* with `cache: false`.
+	*
+	* Assert which requests the response-cache gateway forwarded to the cached
+	* entrypoint, and with which resolved partitions, via
+	* `module.gateway.loopbacks` — in call order, mirroring
+	* `module.cache.purges`. An empty `loopbacks` is the assertion for every
+	* fail-closed case: an unresolved partition, a non-GET, or a `@Cacheable`
+	* route with no `partitionBy` all run inline and never appear here.
+	*
+	* @throws {TestSetupError} This module was compiled with `cache: false`,
+	*   so there is no stub to inspect.
+	*/
+	get gateway() {
+		if (!this.testWorkerExports) throw new TestSetupError("module.gateway is unavailable because this module was compiled with `cache: false`. Remove that option to use the default ctx.exports stub.");
+		return this.testWorkerExports;
+	}
+	/**
 	* Create a WebSocket test request builder for the given path
 	*/
 	ws(path) {
@@ -1355,7 +1457,20 @@ var TestingModule = class {
 	* Execute an HTTP request through HonoApp
 	*/
 	async fetch(request) {
-		return (await this.app.ensureHono()).fetch(request, this.env, this.ctx);
+		const response = await (await this.app.ensureHono()).fetch(request, this.env, this.ctx);
+		await this.flushDeferredWork();
+		return response;
+	}
+	/**
+	* Drain background work the most recent request(s) deferred via `ctx.waitUntil`, including any
+	* follow-up tasks those tasks enqueue. Settles each (errors are surfaced by the work itself, not
+	* here) so deferred side-effects don't outlive the request that triggered them.
+	*/
+	async flushDeferredWork() {
+		while (this.pendingTasks.length > 0) {
+			const batch = this.pendingTasks.splice(0);
+			await Promise.allSettled(batch);
+		}
 	}
 	/**
 	* Run callback in request scope (for DB operations, service access)
@@ -1369,18 +1484,17 @@ var TestingModule = class {
 		return this._requestContainer.resolve(token);
 	}
 	/**
-	* Truncate all non-prisma tables in the database
+	* Truncate mutable tables in the connection's schema(s), honoring a preserve-list.
+	* Migration bookkeeping (`_prisma%`) is always preserved.
 	*/
-	async truncateDb(name) {
+	async truncateDb(name, opts = {}) {
 		const db = this.getDb(name);
-		const tables = await db.$queryRaw`
-      SELECT tablename::text as tablename FROM pg_tables
-      WHERE schemaname = current_schema()
-      AND tablename NOT LIKE '_prisma%'
-    `;
-		if (tables.length === 0) return;
-		const tableList = tables.map((t) => `"${t.tablename}"`).join(", ");
-		await db.$executeRawUnsafe(`TRUNCATE ${tableList} RESTART IDENTITY CASCADE`);
+		const rows = await db.$queryRawUnsafe(buildTableDiscoverySql(opts.schemas ?? [], opts.preserve ?? []));
+		const sql = buildTruncateSql(rows.map((t) => ({
+			schema: t.schemaname,
+			table: t.tablename
+		})));
+		if (sql) await db.$executeRawUnsafe(sql);
 	}
 	/**
 	* Run seeders by class constructor in the request-scoped container
@@ -1396,13 +1510,15 @@ var TestingModule = class {
 	* Assert that a record exists in the database
 	*/
 	async assertDatabaseHas(table, data, name) {
-		expect(await this.getDb(name)[table].findFirst({ where: data }), `Expected ${table} with ${JSON.stringify(data)}`).not.toBeNull();
+		const result = await this.getDb(name)[table].findFirst({ where: data });
+		expect(result, `Expected ${table} with ${JSON.stringify(data)}`).not.toBeNull();
 	}
 	/**
 	* Assert that a record does not exist in the database
 	*/
 	async assertDatabaseMissing(table, data, name) {
-		expect(await this.getDb(name)[table].findFirst({ where: data }), `Expected ${table} NOT to have ${JSON.stringify(data)}`).toBeNull();
+		const result = await this.getDb(name)[table].findFirst({ where: data });
+		expect(result, `Expected ${table} NOT to have ${JSON.stringify(data)}`).toBeNull();
 	}
 	/**
 	* Assert the number of records in a table
@@ -1415,21 +1531,21 @@ var TestingModule = class {
 	* Cleanup - call in afterAll
 	*/
 	async close() {
+		await this.flushDeferredWork();
 		await this._requestContainer.dispose();
-		try {
-			await this.app.shutdown();
-		} finally {
-			if (this.isolatedDatabase) try {
-				await dropDatabase(this.isolatedDatabase.adminConnectionString, this.isolatedDatabase.name);
-			} catch (error) {
-				console.warn(`[stratal-testing] Failed to drop isolated test database "${this.isolatedDatabase.name}"; it will be reclaimed by the next run's stale-database sweep.`, error);
-			}
-		}
+		await this.app.shutdown();
 	}
 };
 //#endregion
 //#region src/core/testing-module-builder.ts
 /**
+* This isolate's worker-database lease, per base connection string. The pool
+* runs each test file in its own isolate (`isolate: true`), so the first
+* `compile()` in a file leases and clones a database and later compiles in the
+* same file reuse it. The lease ends when the pool disposes the isolate.
+*/
+const workerDatabases = /* @__PURE__ */ new Map();
+/**
 * Builder for creating test modules with provider overrides
 */
 var TestingModuleBuilder = class {
@@ -1481,28 +1597,40 @@ var TestingModuleBuilder = class {
 			...cf?.env,
 			...this.config.env
 		};
-		const ctx = { waitUntil: cf ? cf.waitUntil : (p) => {
-			p.catch(() => {});
-		} };
-		const isolatedDb = await this.setupIsolatedDatabase(env);
+		const pendingTasks = [];
+		const testWorkersCache = this.config.cache === false ? void 0 : new TestWorkersCache();
+		const testWorkerExports = this.config.cache === false ? void 0 : new TestWorkerExports(testWorkersCache);
+		const ctx = {
+			waitUntil: (promise) => {
+				pendingTasks.push(Promise.resolve(promise).catch(() => void 0));
+				cf?.waitUntil?.(promise);
+			},
+			cache: testWorkersCache,
+			exports: testWorkerExports?.context
+		};
+		markGatewayMode(ctx);
+		await this.attachWorkerDatabase(env);
 		let app = null;
 		try {
 			const allImports = [...Test.getBaseModules(), ...this.config.imports ?? []];
+			const rootModule = this.createTestRootModule({
+				imports: allImports,
+				providers: this.config.providers,
+				controllers: this.config.controllers,
+				consumers: this.config.consumers,
+				jobs: this.config.jobs
+			});
 			app = new Application({
-				module: this.createTestRootModule({
-					imports: allImports,
-					providers: this.config.providers,
-					controllers: this.config.controllers,
-					consumers: this.config.consumers,
-					jobs: this.config.jobs
-				}),
+				module: rootModule,
 				logging: {
 					level: this.config.logging?.level ?? LogLevel.ERROR,
 					formatter: this.config.logging?.formatter ?? "pretty"
 				},
 				env,
 				ctx,
-				exceptionHandler: this.config.exceptionHandler
+				exceptionHandler: this.config.exceptionHandler,
+				trailingSlash: this.config.trailingSlash,
+				versioning: this.config.versioning
 			});
 			await app.initialize();
 			app.container.registerSingleton(STORAGE_TOKENS.StorageService, FakeStorageService);
@@ -1520,49 +1648,56 @@ var TestingModuleBuilder = class {
 				case "factory":
 					app.container.registerFactory(override.token, override.implementation);
 					break;
-				case "existing":
-					app.container.registerExisting(override.token, override.implementation);
-					break;
+				case "existing": app.container.registerExisting(override.token, override.implementation);
 			}
 			await app.ensureHono();
-			return new TestingModule(app, env, ctx, isolatedDb, testEmailProvider);
+			testWorkerExports?.setHandler(async (request, props) => {
+				const hono = await app.ensureHono();
+				const cachedCtx = {
+					waitUntil: ctx.waitUntil.bind(ctx),
+					cache: testWorkersCache,
+					exports: ctx.exports,
+					props
+				};
+				return hono.fetch(request, env, cachedCtx);
+			});
+			return new TestingModule(app, env, ctx, testEmailProvider, pendingTasks, testWorkersCache, testWorkerExports);
 		} catch (error) {
 			if (app) await app.shutdown().catch(() => {});
-			if (isolatedDb) await dropDatabase(isolatedDb.adminConnectionString, isolatedDb.name).catch(() => {});
 			throw error;
 		}
 	}
 	/**
-	* When `STRATAL_TEST_DB_ISOLATION=database`, create a fresh database cloned
-	* from the migrated template and rewrite the Hyperdrive binding's
-	* `connectionString` to target it. The binding name is configurable via
-	* `stratalTest({ database: { binding } })` (defaults to `DB`). Returns the
-	* created name + admin connection so `close()` can drop it, or `null` when
-	* isolation is off. Throws if isolation is on but the binding is missing — a
-	* misconfiguration, not a case to skip.
+	* Point this app's Hyperdrive binding at the database this file leased,
+	* leasing it on the file's first compile. Returns nothing to clean up — the
+	* lease ends with the isolate. No-op when the consumer didn't opt into
+	* `stratalTest({ database })`; throws if they did but no connection string is
+	* configured (a misconfiguration that would otherwise silently skip isolation).
 	*/
-	async setupIsolatedDatabase(env) {
+	async attachWorkerDatabase(env) {
 		const bindings = env;
-		if (normalizeIsolation(bindings["STRATAL_TEST_DB_ISOLATION"]) !== "database") return null;
-		const bindingName = bindings["STRATAL_TEST_DB_BINDING"] ?? "DB";
+		const bindingName = bindings[BINDING_ENV_VAR];
+		if (!bindingName) return;
 		const db = bindings[bindingName];
 		const base = db?.connectionString;
-		if (!base) throw new Error(`Database isolation is 'database' but no \`${bindingName}\` Hyperdrive binding with a connectionString was found. Provide it via \`stratalTest({ miniflare: { hyperdrives: { ${bindingName} } } })\`, or set isolation to 'shared'.`);
-		const adminConnectionString = deriveAdminConnectionString(base);
-		const name = deriveDbName(base);
-		await createDatabaseFromTemplate(adminConnectionString, name, deriveTemplateName(base));
+		if (!base) throw new Error(`[stratal-testing] stratalTest({ database }) is enabled but no \`${bindingName}\` Hyperdrive binding with a connectionString was found. Provide it via miniflare.hyperdrives (e.g. { ${bindingName}: DATABASE_URL }), or drop the \`database\` option.`);
+		let lease = workerDatabases.get(base);
+		if (!lease) {
+			lease = leaseWorkerDatabase(base).catch((error) => {
+				workerDatabases.delete(base);
+				throw error;
+			});
+			workerDatabases.set(base, lease);
+		}
+		const { connectionString } = await lease;
 		const isolated = Object.create(Object.getPrototypeOf(db), Object.getOwnPropertyDescriptors(db));
 		Object.defineProperty(isolated, "connectionString", {
-			value: buildConnectionString(base, name),
+			value: connectionString,
 			enumerable: true,
 			configurable: true,
 			writable: true
 		});
 		bindings[bindingName] = isolated;
-		return {
-			name,
-			adminConnectionString
-		};
 	}
 	/**
 	* Create a test root module with the given options
@@ -1689,7 +1824,8 @@ var MockFetch = class {
 	* ```
 	*/
 	mockJsonResponse(url, data, options = {}) {
-		const handler = http$1[(options.method ?? "GET").toLowerCase()](url, () => HttpResponse$1.json(data, {
+		const method = (options.method ?? "GET").toLowerCase();
+		const handler = http$1[method](url, () => HttpResponse$1.json(data, {
 			status: options.status ?? 200,
 			headers: options.headers
 		}));
@@ -1739,32 +1875,6 @@ function createMockFetch(handlers) {
 	return new MockFetch(handlers);
 }
 //#endregion
-//#region src/errors/test-error.ts
-/**
-* Base error class for all test framework errors.
-* Extends from Error and allows easy identification via `instanceof`.
-*/
-var TestError = class extends Error {
-	cause;
-	constructor(message, cause) {
-		super(message);
-		this.cause = cause;
-		this.name = "TestError";
-		Error.captureStackTrace(this, this.constructor);
-	}
-};
-//#endregion
-//#region src/errors/setup-error.ts
-/**
-* Error thrown when test setup fails.
-* Examples: schema creation failure, migration failure, application bootstrap failure.
-*/
-var TestSetupError = class extends TestError {
-	constructor(message, cause) {
-		super(`Test setup failed: ${message}`, cause);
-	}
-};
-//#endregion
 export { ActingAs, HttpResponse, MockFetch, ProviderOverrideBuilder, Test, TestCommandRequest, TestCommandResult, TestError, TestHttpClient, TestHttpRequest, TestResponse, TestSetupError, TestSseConnection, TestSseRequest, TestWsConnection, TestWsRequest, TestingModule, TestingModuleBuilder, createMockFetch, getValueAtPath, hasValueAtPath, http };
 
 //# sourceMappingURL=index.mjs.map