@danceroutine/tango-testing 0.1.0 → 1.0.0

package/dist/integration-BrJw6NzG.js

@@ -0,0 +1,747 @@
+import { __export } from "./chunk-BkvOhyD0.js";
+import { aDBClient } from "./aDBClient-W6eXsK3X.js";
+import { vi } from "vitest";
+import { QuerySet, initializeTangoRuntime, resetTangoRuntime } from "@danceroutine/tango-orm";
+import { MigrationRunner, MigrationRunner as MigrationRunner$1, createDefaultIntrospectorStrategy } from "@danceroutine/tango-migrations";
+import { defineConfig, loadConfig } from "@danceroutine/tango-config";
+import { spawn } from "node:child_process";
+import { quoteSqlIdentifier, quoteSqlIdentifier as quoteSqlIdentifier$1, quoteSqlIdentifier as quoteSqlIdentifier$2, validateSqlIdentifier, validateSqlIdentifier as validateSqlIdentifier$1, validateSqlIdentifier as validateSqlIdentifier$2 } from "@danceroutine/tango-core";
+import { PostgresAdapter, SqliteAdapter } from "@danceroutine/tango-orm/connection";
+import { rm } from "node:fs/promises";
+
+//#region src/integration/domain/Dialect.ts
+const Dialect = {
+	Sqlite: "sqlite",
+	Postgres: "postgres"
+};
+
+//#endregion
+//#region src/integration/domain/ResetMode.ts
+const ResetMode = {
+	Transaction: "transaction",
+	Truncate: "truncate",
+	DropSchema: "drop-schema"
+};
+
+//#endregion
+//#region src/integration/domain/index.ts
+var domain_exports = {};
+__export(domain_exports, {
+	Dialect: () => Dialect,
+	ResetMode: () => ResetMode
+});
+
+//#endregion
+//#region src/integration/migrations/AssertMigrationPlan.ts
+async function assertMigrationPlan(harness, options) {
+	const runner = harness.migrationRunner(options.migrationsDir);
+	const plan = await runner.plan();
+	for (const snippet of options.expectSqlContains ?? []) if (!plan.includes(snippet)) throw new Error(`Expected migration plan to contain: ${snippet}`);
+	return plan;
+}
+
+//#endregion
+//#region src/integration/migrations/ApplyAndVerifyMigrations.ts
+async function applyAndVerifyMigrations(harness, options) {
+	const runner = harness.migrationRunner(options.migrationsDir);
+	await runner.apply(options.toId);
+	const statuses = await runner.status();
+	for (const id of options.expectedAppliedIds ?? []) {
+		const row = statuses.find((status) => status.id === id);
+		if (!row || !row.applied) throw new Error(`Expected migration ${id} to be applied`);
+	}
+	return { statuses };
+}
+
+//#endregion
+//#region src/integration/migrations/IntrospectSchema.ts
+const introspectorStrategy = createDefaultIntrospectorStrategy();
+async function introspectSchema(harness) {
+	if (harness.dialect !== Dialect.Postgres && harness.dialect !== Dialect.Sqlite) throw new Error(`No introspector registered for dialect: ${String(harness.dialect)}`);
+	const dialect = harness.dialect === Dialect.Postgres ? "postgres" : "sqlite";
+	return introspectorStrategy.introspect(dialect, harness.dbClient);
+}
+
+//#endregion
+//#region src/integration/migrations/index.ts
+var migrations_exports = {};
+__export(migrations_exports, {
+	applyAndVerifyMigrations: () => applyAndVerifyMigrations,
+	assertMigrationPlan: () => assertMigrationPlan,
+	introspectSchema: () => introspectSchema
+});
+
+//#endregion
+//#region src/integration/conformance/runDialectConformanceSuite.ts
+async function runDialectConformanceSuite(strategy, options = {}) {
+	const harness = await strategy.create(options.createOptions);
+	if (harness.dialect !== strategy.dialect) throw new Error(`Conformance failed: harness dialect '${String(harness.dialect)}' does not match strategy dialect '${String(strategy.dialect)}'`);
+	if (harness.capabilities !== strategy.capabilities) throw new Error("Conformance failed: harness capabilities must be strategy capabilities reference");
+	let resetBeforeSetupThrew = false;
+	try {
+		await harness.reset();
+	} catch {
+		resetBeforeSetupThrew = true;
+	}
+	if (!resetBeforeSetupThrew) throw new Error("Conformance failed: reset() must throw before setup()");
+	await harness.setup();
+	await harness.reset();
+	harness.migrationRunner(options.migrationsDir ?? "/tmp/migrations");
+	await harness.teardown();
+	let dbClientAfterTeardownThrew = false;
+	try {
+		harness.dbClient;
+	} catch {
+		dbClientAfterTeardownThrew = true;
+	}
+	if (!dbClientAfterTeardownThrew) throw new Error("Conformance failed: dbClient getter must throw after teardown()");
+}
+
+//#endregion
+//#region src/integration/conformance/index.ts
+var conformance_exports = {};
+__export(conformance_exports, { runDialectConformanceSuite: () => runDialectConformanceSuite });
+
+//#endregion
+//#region src/integration/runtime/aTangoConfig.ts
+function aTangoConfig(options = {}) {
+	const adapter = options.adapter ?? "sqlite";
+	return defineConfig({
+		current: "test",
+		environments: {
+			development: {
+				name: "development",
+				db: adapter === "sqlite" ? {
+					adapter: "sqlite",
+					filename: ":memory:",
+					maxConnections: 1
+				} : {
+					adapter: "postgres",
+					url: "postgres://postgres:postgres@localhost:5432/tango",
+					maxConnections: 1
+				},
+				migrations: {
+					dir: "migrations",
+					online: adapter === "postgres"
+				}
+			},
+			test: {
+				name: "test",
+				db: adapter === "sqlite" ? {
+					adapter: "sqlite",
+					filename: ":memory:",
+					maxConnections: 1
+				} : {
+					adapter: "postgres",
+					url: "postgres://postgres:postgres@localhost:5432/tango_test",
+					maxConnections: 1
+				},
+				migrations: {
+					dir: "migrations",
+					online: adapter === "postgres"
+				}
+			},
+			production: {
+				name: "production",
+				db: adapter === "sqlite" ? {
+					adapter: "sqlite",
+					filename: ":memory:",
+					maxConnections: 1
+				} : {
+					adapter: "postgres",
+					url: "postgres://postgres:postgres@localhost:5432/tango",
+					maxConnections: 1
+				},
+				migrations: {
+					dir: "migrations",
+					online: adapter === "postgres"
+				}
+			}
+		}
+	});
+}
+
+//#endregion
+//#region src/integration/runtime/setupTestTangoRuntime.ts
+async function setupTestTangoRuntime(options = {}) {
+	await resetTangoRuntime();
+	return initializeTangoRuntime(() => aTangoConfig(options));
+}
+
+//#endregion
+//#region src/integration/runtime/index.ts
+var runtime_exports = {};
+__export(runtime_exports, {
+	aTangoConfig: () => aTangoConfig,
+	setupTestTangoRuntime: () => setupTestTangoRuntime
+});
+
+//#endregion
+//#region src/integration/smoke/AppProcessHarness.ts
+const DEFAULT_READY_TIMEOUT_MS = 3e4;
+const DEFAULT_READY_INTERVAL_MS = 250;
+const DEFAULT_STOP_TIMEOUT_MS = 1e4;
+const MAX_LOG_BUFFER_CHARS = 2e4;
+const defaultDeps = {
+	spawnProcess: (command, args, options) => spawn(command, args, options),
+	fetchImpl: fetch,
+	sleep: (ms) => new Promise((resolve) => {
+		setTimeout(resolve, ms);
+	})
+};
+var AppProcessHarness = class AppProcessHarness {
+	static BRAND = "tango.testing.app_process_harness";
+	__tangoBrand = AppProcessHarness.BRAND;
+	child;
+	baseUrl;
+	readyUrl;
+	readyTimeoutMs;
+	readyIntervalMs;
+	stopTimeoutMs;
+	deps;
+	stopped = false;
+	stdoutBuffer = "";
+	stderrBuffer = "";
+	constructor(options, deps) {
+		this.baseUrl = options.baseUrl.replace(/\/+$/, "");
+		this.readyUrl = `${this.baseUrl}${normalizePath(options.readyPath ?? "/health")}`;
+		this.readyTimeoutMs = options.readyTimeoutMs ?? DEFAULT_READY_TIMEOUT_MS;
+		this.readyIntervalMs = options.readyIntervalMs ?? DEFAULT_READY_INTERVAL_MS;
+		this.stopTimeoutMs = options.stopTimeoutMs ?? DEFAULT_STOP_TIMEOUT_MS;
+		this.deps = deps;
+		this.child = this.deps.spawnProcess(options.command, options.args ?? [], {
+			cwd: options.cwd,
+			env: {
+				...process.env,
+				...options.env
+			},
+			stdio: "pipe"
+		});
+		this.child.stdout?.on("data", (chunk) => {
+			this.stdoutBuffer = appendBuffer(this.stdoutBuffer, String(chunk));
+		});
+		this.child.stderr?.on("data", (chunk) => {
+			this.stderrBuffer = appendBuffer(this.stderrBuffer, String(chunk));
+		});
+	}
+	/**
+	* Narrow an unknown value to the smoke-test harness that owns a child process.
+	*/
+	static isAppProcessHarness(value) {
+		return typeof value === "object" && value !== null && value.__tangoBrand === AppProcessHarness.BRAND;
+	}
+	/**
+	* Spawn the target process and wait until its readiness endpoint responds successfully.
+	*/
+	static async start(options, deps = {}) {
+		const mergedDeps = {
+			...defaultDeps,
+			...deps
+		};
+		const harness = new AppProcessHarness(options, mergedDeps);
+		await harness.waitForReady();
+		return harness;
+	}
+	/**
+	* Return the buffered stdout log for recent process output.
+	*/
+	getStdoutLog() {
+		return this.stdoutBuffer;
+	}
+	/**
+	* Return the buffered stderr log for recent process output.
+	*/
+	getStderrLog() {
+		return this.stderrBuffer;
+	}
+	/**
+	* Return stdout and stderr in a single formatted string for debugging failures.
+	*/
+	getCombinedLog() {
+		const stdout = this.stdoutBuffer.trim();
+		const stderr = this.stderrBuffer.trim();
+		if (!stdout && !stderr) return "";
+		return [`[stdout]\n${stdout}`, `[stderr]\n${stderr}`].join("\n\n").trim();
+	}
+	/**
+	* Issue an HTTP request against the managed application process.
+	*/
+	async request(path, init) {
+		const target = path.startsWith("http") ? path : `${this.baseUrl}${normalizePath(path)}`;
+		return this.deps.fetchImpl(target, init);
+	}
+	/**
+	* Assert an HTTP response status and include process logs when it mismatches.
+	*/
+	async assertResponseStatus(response, expectedStatus, label) {
+		if (response.status === expectedStatus) return;
+		let bodyText;
+		try {
+			bodyText = await response.text();
+		} catch (error) {
+			bodyText = `failed to read response body: ${String(error)}`;
+		}
+		throw new Error([
+			`${label}. expected ${String(expectedStatus)} got ${String(response.status)}`,
+			`response body: ${bodyText}`,
+			`process logs:\n${this.getCombinedLog()}`
+		].join("\n"));
+	}
+	/**
+	* Stop the managed process, escalating from SIGTERM to SIGKILL when necessary.
+	*/
+	async stop() {
+		if (this.stopped) return;
+		this.stopped = true;
+		if (this.child.exitCode !== null || this.child.killed) return;
+		this.child.kill("SIGTERM");
+		const exited = await this.waitForExit(this.stopTimeoutMs);
+		if (!exited && !this.child.killed) {
+			this.child.kill("SIGKILL");
+			await this.waitForExit(this.stopTimeoutMs);
+		}
+	}
+	async waitForReady() {
+		const deadline = Date.now() + this.readyTimeoutMs;
+		while (Date.now() < deadline) {
+			if (this.child.exitCode !== null) throw new Error(`Process exited before ready check succeeded (exitCode=${String(this.child.exitCode)}).\n${this.getCombinedLog()}`);
+			try {
+				const response = await this.deps.fetchImpl(this.readyUrl);
+				if (response.ok) return;
+			} catch {}
+			await this.deps.sleep(this.readyIntervalMs);
+		}
+		await this.stop();
+		throw new Error(`Timed out waiting for readiness at ${this.readyUrl}.\n${this.getCombinedLog()}`);
+	}
+	async waitForExit(timeoutMs) {
+		if (this.child.exitCode !== null) return true;
+		return await new Promise((resolve) => {
+			const timer = setTimeout(() => {
+				this.child.off("exit", onExit);
+				resolve(false);
+			}, timeoutMs);
+			const onExit = () => {
+				clearTimeout(timer);
+				resolve(true);
+			};
+			this.child.once("exit", onExit);
+		});
+	}
+};
+function appendBuffer(current, chunk) {
+	const next = current + chunk;
+	if (next.length <= MAX_LOG_BUFFER_CHARS) return next;
+	return next.slice(next.length - MAX_LOG_BUFFER_CHARS);
+}
+function normalizePath(path) {
+	if (!path) return "/";
+	return path.startsWith("/") ? path : `/${path}`;
+}
+
+//#endregion
+//#region src/integration/smoke/index.ts
+var smoke_exports = {};
+__export(smoke_exports, { AppProcessHarness: () => AppProcessHarness });
+
+//#endregion
+//#region src/integration/anIntegrationHarness.ts
+const defaultCapabilities = {
+	transactionalDDL: true,
+	supportsSchemas: false,
+	supportsConcurrentIndex: false,
+	supportsDeferredFkValidation: false,
+	supportsJsonb: false
+};
+function anIntegrationHarness(overrides = {}) {
+	return {
+		dialect: Dialect.Sqlite,
+		capabilities: defaultCapabilities,
+		resetMode: ResetMode.DropSchema,
+		dbClient: aDBClient(),
+		setup: vi.fn(async () => {}),
+		reset: vi.fn(async () => {}),
+		teardown: vi.fn(async () => {}),
+		migrationRunner: vi.fn(() => ({})),
+		...overrides
+	};
+}
+
+//#endregion
+//#region src/integration/HarnessStrategyRegistry.ts
+var HarnessStrategyRegistry = class HarnessStrategyRegistry {
+	static BRAND = "tango.testing.harness_strategy_registry";
+	__tangoBrand = HarnessStrategyRegistry.BRAND;
+	strategies = new Map();
+	/**
+	* Narrow an unknown value to `HarnessStrategyRegistry`.
+	*/
+	static isHarnessStrategyRegistry(value) {
+		return typeof value === "object" && value !== null && value.__tangoBrand === HarnessStrategyRegistry.BRAND;
+	}
+	/**
+	* Register or replace a dialect strategy.
+	*/
+	register(strategy) {
+		this.strategies.set(String(strategy.dialect), strategy);
+		return this;
+	}
+	/**
+	* Resolve a strategy for a dialect, or throw if none is registered.
+	*/
+	get(dialect) {
+		const strategy = this.strategies.get(String(dialect));
+		if (!strategy) throw new Error(`No harness strategy registered for dialect: ${String(dialect)}`);
+		return strategy;
+	}
+	/**
+	* List all registered strategies.
+	*/
+	list() {
+		return [...this.strategies.values()];
+	}
+};
+
+//#endregion
+//#region src/integration/config.ts
+function readNumber(value) {
+	if (!value) return undefined;
+	const parsed = Number(value);
+	return Number.isFinite(parsed) ? parsed : undefined;
+}
+function resolveAdapterConfig(dialect, opts) {
+	const fromOptions = opts.config ?? {};
+	if (opts.tangoConfigLoader) {
+		const loaded = loadConfig(opts.tangoConfigLoader);
+		const current = loaded.current.db;
+		const merged = {
+			url: fromOptions.url ?? current.url,
+			host: fromOptions.host ?? current.host,
+			port: fromOptions.port ?? current.port,
+			database: fromOptions.database ?? current.database,
+			user: fromOptions.user ?? current.user,
+			password: fromOptions.password ?? current.password,
+			filename: fromOptions.filename ?? current.filename,
+			maxConnections: fromOptions.maxConnections ?? current.maxConnections
+		};
+		if (dialect === Dialect.Sqlite) merged.filename = opts.sqliteFile ?? merged.filename ?? ":memory:";
+		return merged;
+	}
+	if (dialect === Dialect.Postgres) return {
+		url: fromOptions.url ?? process.env.TANGO_DATABASE_URL ?? process.env.DATABASE_URL,
+		host: fromOptions.host ?? process.env.TANGO_DB_HOST,
+		port: fromOptions.port ?? readNumber(process.env.TANGO_DB_PORT),
+		database: fromOptions.database ?? process.env.TANGO_DB_NAME,
+		user: fromOptions.user ?? process.env.TANGO_DB_USER,
+		password: fromOptions.password ?? process.env.TANGO_DB_PASSWORD,
+		maxConnections: fromOptions.maxConnections ?? 10
+	};
+	return {
+		filename: opts.sqliteFile ?? fromOptions.filename ?? process.env.TANGO_SQLITE_FILENAME ?? ":memory:",
+		maxConnections: fromOptions.maxConnections ?? 1
+	};
+}
+
+//#endregion
+//#region src/integration/strategies/PostgresHarnessStrategy.ts
+var PostgresHarnessStrategy = class PostgresHarnessStrategy {
+	static BRAND = "tango.testing.postgres_harness_strategy";
+	__tangoBrand = PostgresHarnessStrategy.BRAND;
+	dialect = Dialect.Postgres;
+	capabilities = {
+		transactionalDDL: true,
+		supportsSchemas: true,
+		supportsConcurrentIndex: true,
+		supportsDeferredFkValidation: true,
+		supportsJsonb: true
+	};
+	/**
+	* Narrow an unknown value to the PostgreSQL integration harness strategy.
+	*/
+	static isPostgresHarnessStrategy(value) {
+		return typeof value === "object" && value !== null && value.__tangoBrand === PostgresHarnessStrategy.BRAND;
+	}
+	static buildSchemaName(explicitSchema) {
+		if (explicitSchema) return explicitSchema;
+		const random = Math.random().toString(36).slice(2, 8);
+		return `tango_test_${Date.now()}_${random}`;
+	}
+	/**
+	* Create a configured Postgres integration harness instance.
+	*/
+	async create(options = {}) {
+		const config = resolveAdapterConfig(Dialect.Postgres, {
+			config: options.config,
+			tangoConfigLoader: options.tangoConfigLoader
+		});
+		const adapter = new PostgresAdapter();
+		const schemaName = PostgresHarnessStrategy.buildSchemaName(options.schema);
+		const resetMode = options.resetMode ?? ResetMode.DropSchema;
+		let client = null;
+		const ensureSearchPath = async () => {
+			const dbClient = client;
+			const schema = quoteSqlIdentifier$2(validateSqlIdentifier$2(schemaName, "schema"), "postgres");
+			await dbClient.query(`CREATE SCHEMA IF NOT EXISTS ${schema}`);
+			await dbClient.query(`SET search_path TO ${schema}`);
+		};
+		const recreateSchema = async () => {
+			const dbClient = client;
+			const schema = quoteSqlIdentifier$2(validateSqlIdentifier$2(schemaName, "schema"), "postgres");
+			await dbClient.query(`DROP SCHEMA IF EXISTS ${schema} CASCADE`);
+			await dbClient.query(`CREATE SCHEMA ${schema}`);
+			await dbClient.query(`SET search_path TO ${schema}`);
+		};
+		const harness = {
+			dialect: Dialect.Postgres,
+			capabilities: this.capabilities,
+			resetMode,
+			get dbClient() {
+				if (!client) throw new Error("Postgres harness not initialized. Call setup() first.");
+				return client;
+			},
+			async setup() {
+				client = await adapter.connect(config);
+				await ensureSearchPath();
+			},
+			async reset() {
+				if (!client) throw new Error("Postgres harness not initialized. Call setup() first.");
+				if (resetMode === ResetMode.DropSchema || resetMode === ResetMode.Transaction) {
+					await recreateSchema();
+					return;
+				}
+				const { rows } = await client.query(`SELECT table_name FROM information_schema.tables WHERE table_schema = $1 AND table_type = 'BASE TABLE'`, [schemaName]);
+				for (const row of rows) {
+					const schema = quoteSqlIdentifier$2(validateSqlIdentifier$2(schemaName, "schema"), "postgres");
+					const table = quoteSqlIdentifier$2(validateSqlIdentifier$2(String(row.table_name), "table"), "postgres");
+					await client.query(`TRUNCATE TABLE ${schema}.${table} RESTART IDENTITY CASCADE`);
+				}
+				await client.query(`SET search_path TO ${quoteSqlIdentifier$2(validateSqlIdentifier$2(schemaName, "schema"), "postgres")}`);
+			},
+			async teardown() {
+				if (!client) return;
+				try {
+					await client.query(`DROP SCHEMA IF EXISTS ${quoteSqlIdentifier$2(validateSqlIdentifier$2(schemaName, "schema"), "postgres")} CASCADE`);
+				} finally {
+					await client.close();
+					client = null;
+				}
+			},
+			migrationRunner(migrationsDir) {
+				if (!client) throw new Error("Postgres harness not initialized. Call setup() first.");
+				return new MigrationRunner$1(client, "postgres", migrationsDir);
+			}
+		};
+		return harness;
+	}
+};
+
+//#endregion
+//#region src/integration/strategies/SqliteHarnessStrategy.ts
+var SqliteHarnessStrategy = class SqliteHarnessStrategy {
+	static BRAND = "tango.testing.sqlite_harness_strategy";
+	__tangoBrand = SqliteHarnessStrategy.BRAND;
+	dialect = Dialect.Sqlite;
+	capabilities = {
+		transactionalDDL: true,
+		supportsSchemas: false,
+		supportsConcurrentIndex: false,
+		supportsDeferredFkValidation: false,
+		supportsJsonb: false
+	};
+	/**
+	* Narrow an unknown value to the SQLite integration harness strategy.
+	*/
+	static isSqliteHarnessStrategy(value) {
+		return typeof value === "object" && value !== null && value.__tangoBrand === SqliteHarnessStrategy.BRAND;
+	}
+	static async dropAllTables(client) {
+		const { rows } = await client.query("SELECT name FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%'");
+		for (const row of rows) {
+			const table = quoteSqlIdentifier$1(validateSqlIdentifier$1(String(row.name), "table"), "sqlite");
+			await client.query(`DROP TABLE IF EXISTS ${table}`);
+		}
+	}
+	/**
+	* Create a configured SQLite integration harness instance.
+	*/
+	async create(options = {}) {
+		const config = resolveAdapterConfig(Dialect.Sqlite, {
+			config: options.config,
+			tangoConfigLoader: options.tangoConfigLoader,
+			sqliteFile: options.sqliteFile
+		});
+		const adapter = new SqliteAdapter();
+		const resetMode = options.resetMode ?? ResetMode.DropSchema;
+		let client = null;
+		const reconnect = async () => {
+			client = await adapter.connect(config);
+			return client;
+		};
+		const harness = {
+			dialect: Dialect.Sqlite,
+			capabilities: this.capabilities,
+			resetMode,
+			get dbClient() {
+				if (!client) throw new Error("Sqlite harness not initialized. Call setup() first.");
+				return client;
+			},
+			async setup() {
+				await reconnect();
+			},
+			async reset() {
+				if (!client) throw new Error("Sqlite harness not initialized. Call setup() first.");
+				if (resetMode === ResetMode.DropSchema && config.filename && config.filename !== ":memory:") {
+					await client.close();
+					await rm(config.filename, { force: true });
+					await reconnect();
+					return;
+				}
+				await SqliteHarnessStrategy.dropAllTables(client);
+			},
+			async teardown() {
+				if (client) {
+					await client.close();
+					client = null;
+				}
+				if (config.filename && config.filename !== ":memory:") await rm(config.filename, { force: true });
+			},
+			migrationRunner(migrationsDir) {
+				if (!client) throw new Error("Sqlite harness not initialized. Call setup() first.");
+				return new MigrationRunner(client, "sqlite", migrationsDir);
+			}
+		};
+		return harness;
+	}
+};
+
+//#endregion
+//#region src/integration/TestHarness.ts
+var TestHarness = class TestHarness {
+	static BRAND = "tango.testing.test_harness";
+	static defaultRegistry = null;
+	__tangoBrand = TestHarness.BRAND;
+	/**
+	* Narrow an unknown value to `TestHarness`.
+	*/
+	static isTestHarness(value) {
+		return typeof value === "object" && value !== null && value.__tangoBrand === TestHarness.BRAND;
+	}
+	/**
+	* Register a harness strategy on the shared default registry.
+	*/
+	static registerStrategy(strategy) {
+		this.ensureRegistry().register(strategy);
+	}
+	/**
+	* Return the shared harness strategy registry.
+	*/
+	static getRegistry() {
+		return this.ensureRegistry();
+	}
+	/**
+	* Create a dialect-specific harness from the registry.
+	*/
+	static async forDialect(args, registry) {
+		const selectedRegistry = registry ?? this.ensureRegistry();
+		const strategy = selectedRegistry.get(args.dialect);
+		return strategy.create(args.options);
+	}
+	/**
+	* Convenience helper for a SQLite test harness.
+	*/
+	static async sqlite(options) {
+		return this.forDialect({
+			dialect: Dialect.Sqlite,
+			options
+		});
+	}
+	/**
+	* Convenience helper for a Postgres test harness.
+	*/
+	static async postgres(options) {
+		return this.forDialect({
+			dialect: Dialect.Postgres,
+			options
+		});
+	}
+	static ensureRegistry() {
+		if (this.defaultRegistry) return this.defaultRegistry;
+		const registry = new HarnessStrategyRegistry();
+		registry.register(new SqliteHarnessStrategy());
+		registry.register(new PostgresHarnessStrategy());
+		this.defaultRegistry = registry;
+		return registry;
+	}
+};
+
+//#endregion
+//#region src/integration/orm/seedTable.ts
+async function seedTable(harness, table, rows) {
+	if (rows.length === 0) return;
+	const columns = Object.keys(rows[0] ?? {});
+	if (columns.length === 0) return;
+	const dialect = harness.dialect;
+	const safeTable = quoteSqlIdentifier(validateSqlIdentifier(table, "table"), dialect);
+	const safeColumns = columns.map((column) => quoteSqlIdentifier(validateSqlIdentifier(column, "column", columns), dialect));
+	for (const row of rows) {
+		const values = columns.map((column) => {
+			const value = row[column];
+			if (harness.dialect === Dialect.Sqlite && typeof value === "boolean") return value ? 1 : 0;
+			return value;
+		});
+		const placeholders = harness.dialect === Dialect.Postgres ? columns.map((_, index) => `$${index + 1}`).join(", ") : columns.map(() => "?").join(", ");
+		await harness.dbClient.query(`INSERT INTO ${safeTable} (${safeColumns.join(", ")}) VALUES (${placeholders})`, values);
+	}
+}
+
+//#endregion
+//#region src/integration/orm/createQuerySetFixture.ts
+function createQuerySetFixture(input) {
+	const executor = {
+		meta: input.meta,
+		client: input.harness.dbClient,
+		dialect: input.harness.dialect,
+		run: async (compiled) => {
+			const result = await input.harness.dbClient.query(compiled.sql, compiled.params);
+			return result.rows;
+		}
+	};
+	return new QuerySet(executor);
+}
+
+//#endregion
+//#region src/integration/orm/expectQueryResult.ts
+async function expectQueryResult(actual, expected) {
+	const resolved = await actual;
+	if (JSON.stringify(resolved) !== JSON.stringify(expected)) throw new Error(`Expected query result ${JSON.stringify(expected)}, got ${JSON.stringify(resolved)}`);
+}
+
+//#endregion
+//#region src/integration/index.ts
+var integration_exports = {};
+__export(integration_exports, {
+	AppProcessHarness: () => AppProcessHarness,
+	Dialect: () => Dialect,
+	HarnessStrategyRegistry: () => HarnessStrategyRegistry,
+	ResetMode: () => ResetMode,
+	TestHarness: () => TestHarness,
+	aTangoConfig: () => aTangoConfig,
+	anIntegrationHarness: () => anIntegrationHarness,
+	applyAndVerifyMigrations: () => applyAndVerifyMigrations,
+	assertMigrationPlan: () => assertMigrationPlan,
+	conformance: () => conformance_exports,
+	createQuerySetFixture: () => createQuerySetFixture,
+	domain: () => domain_exports,
+	expectQueryResult: () => expectQueryResult,
+	introspectSchema: () => introspectSchema,
+	migrations: () => migrations_exports,
+	runDialectConformanceSuite: () => runDialectConformanceSuite,
+	runtime: () => runtime_exports,
+	seedTable: () => seedTable,
+	setupTestTangoRuntime: () => setupTestTangoRuntime,
+	smoke: () => smoke_exports
+});
+
+//#endregion
+export { AppProcessHarness, Dialect, HarnessStrategyRegistry, ResetMode, TestHarness, aTangoConfig, anIntegrationHarness, applyAndVerifyMigrations, assertMigrationPlan, conformance_exports, createQuerySetFixture, domain_exports, expectQueryResult, integration_exports, introspectSchema, migrations_exports, runDialectConformanceSuite, runtime_exports, seedTable, setupTestTangoRuntime, smoke_exports };
+//# sourceMappingURL=integration-BrJw6NzG.js.map