@danceroutine/tango-testing 0.1.0

package/dist/assertions/assertions.d.ts

@@ -0,0 +1,7 @@
+import type { GenericModelFactory } from '../factories';
+/**
+ * Assertion helpers for Tango models.
+ */
+export declare const assertions: {
+    matchesSchema<TModel extends GenericModelFactory<Record<string, unknown>, unknown>>(model: TModel, data: unknown): asserts data is ReturnType<TModel["parse"]>;
+};

package/dist/assertions/assertions.js

@@ -0,0 +1,8 @@
+/**
+ * Assertion helpers for Tango models.
+ */
+export const assertions = {
+    matchesSchema(model, data) {
+        model.parse(data);
+    },
+};

package/dist/assertions/index.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Domain boundary barrel: centralizes this subdomain's public contract.
+ */
+export { assertions } from './assertions';

package/dist/assertions/index.js

@@ -0,0 +1,3 @@
+import { assertions } from "../assertions-CN6KxXhH.js";
+
+export { assertions };

package/dist/assertions-CN6KxXhH.js

@@ -0,0 +1,15 @@
+import { __export } from "./chunk-BkvOhyD0.js";
+
+//#region src/assertions/assertions.ts
+const assertions = { matchesSchema(model, data) {
+	model.parse(data);
+} };
+
+//#endregion
+//#region src/assertions/index.ts
+var assertions_exports = {};
+__export(assertions_exports, { assertions: () => assertions });
+
+//#endregion
+export { assertions, assertions_exports };
+//# sourceMappingURL=assertions-CN6KxXhH.js.map

package/dist/assertions-CN6KxXhH.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"assertions-CN6KxXhH.js","names":["model: TModel","data: unknown"],"sources":["../src/assertions/assertions.ts","../src/assertions/index.ts"],"sourcesContent":["import type { GenericModelFactory } from '../factories';\n\n/**\n * Assertion helpers for Tango models.\n */\nexport const assertions = {\n    matchesSchema<TModel extends GenericModelFactory<any, any>>(\n        model: TModel,\n        data: unknown\n    ): asserts data is ReturnType<TModel['parse']> {\n        model.parse(data);\n    },\n};\n","/**\n * Domain boundary barrel: centralizes this subdomain's public contract.\n */\n\nexport { assertions } from './assertions';\n"],"mappings":";;;MAKa,aAAa,EACtB,cACIA,OACAC,MAC2C;AAC3C,OAAM,MAAM,KAAK;AACpB,EACJ"}

package/dist/chunk-BkvOhyD0.js

@@ -0,0 +1,12 @@
+
+//#region rolldown:runtime
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+};
+
+//#endregion
+export { __export };

package/dist/factories/ModelDataFactory.d.ts

@@ -0,0 +1,18 @@
+export type GenericModelFactory<TInput extends Record<string, unknown> = Record<string, unknown>, TOutput = TInput> = {
+    create(data: TInput): TOutput;
+    parse(data: unknown): TOutput;
+};
+/**
+ * Factory class for generating test data with sequences and defaults.
+ */
+export declare class ModelDataFactory<TModel extends GenericModelFactory<Record<string, unknown>, unknown>> {
+    private model;
+    private defaults;
+    private sequence;
+    constructor(model: TModel, defaults?: Partial<Parameters<TModel['create']>[0]>);
+    build(overrides?: Partial<Parameters<TModel['create']>[0]>): ReturnType<TModel['create']>;
+    buildList(count: number, overrides?: Partial<Parameters<TModel['create']>[0]>): ReturnType<TModel['create']>[];
+    protected sequenceDefaults(): Partial<Parameters<TModel['create']>[0]>;
+    resetSequence(): void;
+    getSequence(): number;
+}

package/dist/factories/ModelDataFactory.js

@@ -0,0 +1,33 @@
+/**
+ * Factory class for generating test data with sequences and defaults.
+ */
+export class ModelDataFactory {
+    model;
+    defaults;
+    sequence = 0;
+    constructor(model, defaults = {}) {
+        this.model = model;
+        this.defaults = defaults;
+    }
+    build(overrides = {}) {
+        this.sequence++;
+        const data = {
+            ...this.defaults,
+            ...this.sequenceDefaults(),
+            ...overrides,
+        };
+        return this.model.create(data);
+    }
+    buildList(count, overrides = {}) {
+        return Array.from({ length: count }, () => this.build(overrides));
+    }
+    sequenceDefaults() {
+        return {};
+    }
+    resetSequence() {
+        this.sequence = 0;
+    }
+    getSequence() {
+        return this.sequence;
+    }
+}

package/dist/factories/index.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Domain boundary barrel: centralizes this subdomain's public contract.
+ */
+export { ModelDataFactory, type GenericModelFactory } from './ModelDataFactory';

package/dist/factories/index.js

@@ -0,0 +1,3 @@
+import { ModelDataFactory } from "../factories-CCAZ6E-g.js";
+
+export { ModelDataFactory };

package/dist/factories-CCAZ6E-g.js

@@ -0,0 +1,40 @@
+import { __export } from "./chunk-BkvOhyD0.js";
+
+//#region src/factories/ModelDataFactory.ts
+var ModelDataFactory = class {
+	sequence = 0;
+	constructor(model, defaults = {}) {
+		this.model = model;
+		this.defaults = defaults;
+	}
+	build(overrides = {}) {
+		this.sequence++;
+		const data = {
+			...this.defaults,
+			...this.sequenceDefaults(),
+			...overrides
+		};
+		return this.model.create(data);
+	}
+	buildList(count, overrides = {}) {
+		return Array.from({ length: count }, () => this.build(overrides));
+	}
+	sequenceDefaults() {
+		return {};
+	}
+	resetSequence() {
+		this.sequence = 0;
+	}
+	getSequence() {
+		return this.sequence;
+	}
+};
+
+//#endregion
+//#region src/factories/index.ts
+var factories_exports = {};
+__export(factories_exports, { ModelDataFactory: () => ModelDataFactory });
+
+//#endregion
+export { ModelDataFactory, factories_exports };
+//# sourceMappingURL=factories-CCAZ6E-g.js.map

package/dist/factories-CCAZ6E-g.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"factories-CCAZ6E-g.js","names":["model: TModel","defaults: Partial<Parameters<TModel['create']>[0]>","overrides: Partial<Parameters<TModel['create']>[0]>","count: number"],"sources":["../src/factories/ModelDataFactory.ts","../src/factories/index.ts"],"sourcesContent":["export type GenericModelFactory<TInput extends Record<string, unknown> = Record<string, unknown>, TOutput = TInput> = {\n    create(data: TInput): TOutput;\n    parse(data: unknown): TOutput;\n};\n\n/**\n * Factory class for generating test data with sequences and defaults.\n */\nexport class ModelDataFactory<TModel extends GenericModelFactory<any, any>> {\n    private sequence = 0;\n\n    constructor(\n        private model: TModel,\n        private defaults: Partial<Parameters<TModel['create']>[0]> = {}\n    ) {}\n\n    public build(overrides: Partial<Parameters<TModel['create']>[0]> = {}): ReturnType<TModel['create']> {\n        this.sequence++;\n        const data = {\n            ...this.defaults,\n            ...this.sequenceDefaults(),\n            ...overrides,\n        };\n        return this.model.create(data as any);\n    }\n\n    public buildList(\n        count: number,\n        overrides: Partial<Parameters<TModel['create']>[0]> = {}\n    ): ReturnType<TModel['create']>[] {\n        return Array.from({ length: count }, () => this.build(overrides));\n    }\n\n    protected sequenceDefaults(): Partial<Parameters<TModel['create']>[0]> {\n        return {} as any;\n    }\n\n    public resetSequence(): void {\n        this.sequence = 0;\n    }\n\n    public getSequence(): number {\n        return this.sequence;\n    }\n}\n","/**\n * Domain boundary barrel: centralizes this subdomain's public contract.\n */\n\nexport { ModelDataFactory, type GenericModelFactory } from './ModelDataFactory';\n"],"mappings":";;;IAQa,mBAAN,MAAqE;CACxE,WAAmB;CAEnB,YACYA,OACAC,WAAqD,CAAE,GACjE;AAAA,OAFU,QAAA;AAAA,OACA,WAAA;CACR;CAEJ,MAAaC,YAAsD,CAAE,GAAgC;AACjG,OAAK;EACL,MAAM,OAAO;GACT,GAAG,KAAK;GACR,GAAG,KAAK,kBAAkB;GAC1B,GAAG;EACN;AACD,SAAO,KAAK,MAAM,OAAO,KAAY;CACxC;CAED,UACIC,OACAD,YAAsD,CAAE,GAC1B;AAC9B,SAAO,MAAM,KAAK,EAAE,QAAQ,MAAO,GAAE,MAAM,KAAK,MAAM,UAAU,CAAC;CACpE;CAED,mBAAuE;AACnE,SAAO,CAAE;CACZ;CAED,gBAA6B;AACzB,OAAK,WAAW;CACnB;CAED,cAA6B;AACzB,SAAO,KAAK;CACf;AACJ"}

package/dist/index.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Bundled exports for Django-style domain drill-down imports, plus curated
+ * top-level symbols for TS-native ergonomic imports.
+ */
+export * as mocks from './mocks/index';
+export * as factories from './factories/index';
+export * as assertionsDomain from './assertions/index';
+export * as integration from './integration/index';
+export * as vitest from './vitest/index';
+export { VERSION as version } from './version';
+export { aMockDBClient, aMockQuerySet, aMockRepository } from './mocks/index';
+export type { DBClient, MockQuerySetResult, RepositoryLike } from './mocks/index';
+export { ModelDataFactory } from './factories/index';
+export type { GenericModelFactory } from './factories/index';
+export { assertions } from './assertions/index';
+export * from './integration/index';

package/dist/index.js

@@ -0,0 +1,12 @@
+import { aMockDBClient, aMockQuerySet, aMockRepository, mocks_exports } from "./mocks-qo-1vCez.js";
+import { ModelDataFactory, factories_exports } from "./factories-CCAZ6E-g.js";
+import { assertions, assertions_exports } from "./assertions-CN6KxXhH.js";
+import { Dialect, HarnessStrategyRegistry, ResetMode, TestHarness, applyAndVerifyMigrations, assertMigrationPlan, createRepositoryFixture, domain_exports, expectQueryResult, integration_exports, introspectSchema, migrations_exports, seedTable } from "./integration-CDdpboYz.js";
+import { vitest_exports } from "./vitest-PxMJue7R.js";
+
+//#region src/version.ts
+const VERSION = "0.1.0";
+
+//#endregion
+export { Dialect, HarnessStrategyRegistry, ModelDataFactory, ResetMode, TestHarness, aMockDBClient, aMockQuerySet, aMockRepository, applyAndVerifyMigrations, assertMigrationPlan, assertions, assertions_exports as assertionsDomain, createRepositoryFixture, domain_exports as domain, expectQueryResult, factories_exports as factories, integration_exports as integration, introspectSchema, migrations_exports as migrations, mocks_exports as mocks, seedTable, VERSION as version, vitest_exports as vitest };
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":[],"sources":["../src/version.ts"],"sourcesContent":["export const VERSION = '0.1.0';\n"],"mappings":";;;;;;;MAAa,UAAU"}

package/dist/integration/HarnessStrategyRegistry.d.ts

@@ -0,0 +1,10 @@
+import type { Dialect, HarnessStrategy } from './domain';
+export declare class HarnessStrategyRegistry {
+    static readonly BRAND: "tango.testing.harness_strategy_registry";
+    readonly __tangoBrand: typeof HarnessStrategyRegistry.BRAND;
+    private readonly strategies;
+    static isHarnessStrategyRegistry(value: unknown): value is HarnessStrategyRegistry;
+    register(strategy: HarnessStrategy): this;
+    get(dialect: Dialect | string): HarnessStrategy;
+    list(): readonly HarnessStrategy[];
+}

package/dist/integration/TestHarness.d.ts

@@ -0,0 +1,17 @@
+import { HarnessStrategyRegistry } from './HarnessStrategyRegistry';
+import { Dialect, type HarnessOptions, type HarnessStrategy, type IntegrationHarness } from './domain';
+export declare class TestHarness {
+    static readonly BRAND: "tango.testing.test_harness";
+    readonly __tangoBrand: typeof TestHarness.BRAND;
+    private static defaultRegistry;
+    static isTestHarness(value: unknown): value is TestHarness;
+    private static ensureRegistry;
+    static registerStrategy(strategy: HarnessStrategy): void;
+    static getRegistry(): HarnessStrategyRegistry;
+    static forDialect(args: {
+        dialect: Dialect | string;
+        options?: HarnessOptions;
+    }, registry?: HarnessStrategyRegistry): Promise<IntegrationHarness>;
+    static sqlite(options?: HarnessOptions): Promise<IntegrationHarness>;
+    static postgres(options?: HarnessOptions): Promise<IntegrationHarness>;
+}

package/dist/integration/config.d.ts

@@ -0,0 +1,7 @@
+import type { AdapterConfig } from '@danceroutine/tango-orm';
+import { Dialect } from './domain';
+export declare function resolveAdapterConfig(dialect: Dialect, opts: {
+    config?: Partial<AdapterConfig>;
+    tangoConfigLoader?: () => unknown;
+    sqliteFile?: string;
+}): AdapterConfig;

package/dist/integration/domain/Dialect.d.ts

@@ -0,0 +1,4 @@
+export declare enum Dialect {
+    Sqlite = "sqlite",
+    Postgres = "postgres"
+}

package/dist/integration/domain/HarnessStrategy.d.ts

@@ -0,0 +1,17 @@
+import type { Dialect } from './Dialect';
+import type { AdapterConfig } from '@danceroutine/tango-orm';
+import type { DialectTestCapabilities } from './IntegrationHarness';
+import type { IntegrationHarness } from './IntegrationHarness';
+import type { ResetMode } from './ResetMode';
+export interface HarnessOptions {
+    config?: Partial<AdapterConfig>;
+    tangoConfigLoader?: () => unknown;
+    resetMode?: ResetMode;
+    schema?: string;
+    sqliteFile?: string;
+}
+export interface HarnessStrategy {
+    readonly dialect: Dialect | string;
+    readonly capabilities: DialectTestCapabilities;
+    create(options?: HarnessOptions): Promise<IntegrationHarness>;
+}

package/dist/integration/domain/IntegrationHarness.d.ts

@@ -0,0 +1,21 @@
+import type { DBClient } from '@danceroutine/tango-orm';
+import type { MigrationRunner } from '@danceroutine/tango-migrations';
+import type { Dialect } from './Dialect';
+import type { ResetMode } from './ResetMode';
+export interface DialectTestCapabilities {
+    transactionalDDL: boolean;
+    supportsSchemas: boolean;
+    supportsConcurrentIndex: boolean;
+    supportsDeferredFkValidation: boolean;
+    supportsJsonb: boolean;
+}
+export interface IntegrationHarness {
+    readonly dialect: Dialect | string;
+    readonly capabilities: DialectTestCapabilities;
+    readonly resetMode: ResetMode;
+    readonly dbClient: DBClient;
+    setup(): Promise<void>;
+    reset(): Promise<void>;
+    teardown(): Promise<void>;
+    migrationRunner(migrationsDir: string): MigrationRunner;
+}

package/dist/integration/domain/ResetMode.d.ts

@@ -0,0 +1,5 @@
+export declare enum ResetMode {
+    Transaction = "transaction",
+    Truncate = "truncate",
+    DropSchema = "drop-schema"
+}

package/dist/integration/domain/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Domain boundary barrel: centralizes this subdomain's public contract.
+ */
+export { Dialect } from './Dialect';
+export type { HarnessOptions, HarnessStrategy } from './HarnessStrategy';
+export type { DialectTestCapabilities, IntegrationHarness } from './IntegrationHarness';
+export { ResetMode } from './ResetMode';

package/dist/integration/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Domain boundary barrel: exposes namespaced exports for Django-style drill-down
+ * imports and curated flat exports for TS-native ergonomics.
+ */
+export * as domain from './domain/index';
+export * as migrations from './migrations/index';
+export * from './domain/index';
+export * from './HarnessStrategyRegistry';
+export * from './TestHarness';
+export * from './migrations/index';
+export * from './orm';

package/dist/integration/index.js

@@ -0,0 +1,3 @@
+import { Dialect, HarnessStrategyRegistry, ResetMode, TestHarness, applyAndVerifyMigrations, assertMigrationPlan, createRepositoryFixture, domain_exports, expectQueryResult, introspectSchema, migrations_exports, seedTable } from "../integration-CDdpboYz.js";
+
+export { Dialect, HarnessStrategyRegistry, ResetMode, TestHarness, applyAndVerifyMigrations, assertMigrationPlan, createRepositoryFixture, domain_exports as domain, expectQueryResult, introspectSchema, migrations_exports as migrations, seedTable };

package/dist/integration/migrations/ApplyAndVerifyMigrations.d.ts

@@ -0,0 +1,13 @@
+import type { IntegrationHarness } from '../domain';
+export type ApplyAndVerifyMigrationsOptions = {
+    migrationsDir: string;
+    toId?: string;
+    expectedAppliedIds?: string[];
+};
+export type MigrationStatus = {
+    id: string;
+    applied: boolean;
+};
+export declare function applyAndVerifyMigrations(harness: IntegrationHarness, options: ApplyAndVerifyMigrationsOptions): Promise<{
+    statuses: MigrationStatus[];
+}>;

package/dist/integration/migrations/AssertMigrationPlan.d.ts

@@ -0,0 +1,6 @@
+import type { IntegrationHarness } from '../domain';
+export type AssertMigrationPlanOptions = {
+    migrationsDir: string;
+    expectSqlContains?: string[];
+};
+export declare function assertMigrationPlan(harness: IntegrationHarness, options: AssertMigrationPlanOptions): Promise<string>;

package/dist/integration/migrations/IntrospectSchema.d.ts

@@ -0,0 +1,2 @@
+import { type IntegrationHarness } from '../domain';
+export declare function introspectSchema(harness: IntegrationHarness): Promise<unknown>;

package/dist/integration/migrations/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Domain boundary barrel: centralizes this subdomain's public contract.
+ */
+export { assertMigrationPlan, type AssertMigrationPlanOptions } from './AssertMigrationPlan';
+export { applyAndVerifyMigrations, type ApplyAndVerifyMigrationsOptions, type MigrationStatus, } from './ApplyAndVerifyMigrations';
+export { introspectSchema } from './IntrospectSchema';

package/dist/integration/orm.d.ts

@@ -0,0 +1,9 @@
+import { Repository } from '@danceroutine/tango-orm';
+import type { RepoMeta } from '@danceroutine/tango-orm/query';
+import { type IntegrationHarness } from './domain';
+export declare function seedTable<T extends Record<string, unknown>>(harness: IntegrationHarness, table: string, rows: T[]): Promise<void>;
+export declare function createRepositoryFixture<TModel extends Record<string, unknown>>(input: {
+    harness: IntegrationHarness;
+    meta: RepoMeta;
+}): Repository<TModel>;
+export declare function expectQueryResult<T>(actual: Promise<T> | T, expected: T): Promise<void>;

package/dist/integration/orm.js

@@ -0,0 +1,39 @@
+import { Repository } from '@danceroutine/tango-orm';
+import { Dialect } from './domain';
+export async function seedTable(harness, table, rows) {
+    if (rows.length === 0) {
+        return;
+    }
+    const columns = Object.keys(rows[0] ?? {});
+    if (columns.length === 0) {
+        return;
+    }
+    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 ${table} (${columns.join(', ')}) VALUES (${placeholders})`, values);
+    }
+}
+export function createRepositoryFixture(input) {
+    class RepositoryFixture extends Repository {
+        meta = input.meta;
+        constructor() {
+            super(input.harness.dbClient, input.harness.dialect);
+        }
+    }
+    return new RepositoryFixture();
+}
+export 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)}`);
+    }
+}

package/dist/integration/strategies/PostgresHarnessStrategy.d.ts

@@ -0,0 +1,10 @@
+import { Dialect, type DialectTestCapabilities, type HarnessOptions, type HarnessStrategy, type IntegrationHarness } from '../domain';
+export declare class PostgresHarnessStrategy implements HarnessStrategy {
+    static readonly BRAND: "tango.testing.postgres_harness_strategy";
+    readonly __tangoBrand: typeof PostgresHarnessStrategy.BRAND;
+    readonly dialect: Dialect;
+    readonly capabilities: DialectTestCapabilities;
+    static isPostgresHarnessStrategy(value: unknown): value is PostgresHarnessStrategy;
+    private static buildSchemaName;
+    create(options?: HarnessOptions): Promise<IntegrationHarness>;
+}

package/dist/integration/strategies/PostgresHarnessStrategy.js

@@ -0,0 +1,95 @@
+import { MigrationRunner } from '@danceroutine/tango-migrations';
+import { PostgresAdapter } from '@danceroutine/tango-orm/connection';
+import { resolveAdapterConfig } from '../config';
+import { Dialect, ResetMode, } from '../domain';
+export 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,
+    };
+    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}`;
+    }
+    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;
+            await dbClient.query(`CREATE SCHEMA IF NOT EXISTS \"${schemaName}\"`);
+            await dbClient.query(`SET search_path TO \"${schemaName}\"`);
+        };
+        const recreateSchema = async () => {
+            const dbClient = client;
+            await dbClient.query(`DROP SCHEMA IF EXISTS \"${schemaName}\" CASCADE`);
+            await dbClient.query(`CREATE SCHEMA \"${schemaName}\"`);
+            await dbClient.query(`SET search_path TO \"${schemaName}\"`);
+        };
+        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) {
+                    await client.query(`TRUNCATE TABLE \"${schemaName}\".\"${row.table_name}\" RESTART IDENTITY CASCADE`);
+                }
+                await client.query(`SET search_path TO \"${schemaName}\"`);
+            },
+            async teardown() {
+                if (!client)
+                    return;
+                try {
+                    await client.query(`DROP SCHEMA IF EXISTS \"${schemaName}\" CASCADE`);
+                }
+                finally {
+                    await client.close();
+                    client = null;
+                }
+            },
+            migrationRunner(migrationsDir) {
+                if (!client) {
+                    throw new Error('Postgres harness not initialized. Call setup() first.');
+                }
+                return new MigrationRunner(client, 'postgres', migrationsDir);
+            },
+        };
+        return harness;
+    }
+}

package/dist/integration/strategies/SqliteHarnessStrategy.d.ts

@@ -0,0 +1,10 @@
+import { Dialect, type DialectTestCapabilities, type HarnessOptions, type HarnessStrategy, type IntegrationHarness } from '../domain';
+export declare class SqliteHarnessStrategy implements HarnessStrategy {
+    static readonly BRAND: "tango.testing.sqlite_harness_strategy";
+    readonly __tangoBrand: typeof SqliteHarnessStrategy.BRAND;
+    readonly dialect: Dialect;
+    readonly capabilities: DialectTestCapabilities;
+    static isSqliteHarnessStrategy(value: unknown): value is SqliteHarnessStrategy;
+    private static dropAllTables;
+    create(options?: HarnessOptions): Promise<IntegrationHarness>;
+}