@geekmidas/testkit 0.0.9 → 0.0.11

package/dist/PostgresObjectionMigrator-C69n7vzr.d.mts

@@ -0,0 +1,77 @@
+import { PostgresMigrator } from "./PostgresMigrator-BlvuQl7d.mjs";
+import { Knex } from "knex";
+
+//#region src/PostgresObjectionMigrator.d.ts
+
+/**
+ * PostgreSQL migrator implementation for Objection.js ORM with Knex.
+ * Extends PostgresMigrator to provide Knex-specific migration functionality.
+ * Automatically creates test databases and applies migrations for testing environments.
+ *
+ * @example
+ * ```typescript
+ * import knex from 'knex';
+ * import { PostgresObjectionMigrator } from '@geekmidas/testkit';
+ *
+ * // Create Knex instance
+ * const db = knex({
+ *   client: 'pg',
+ *   connection: uri,
+ *   migrations: {
+ *     directory: path.join(__dirname, 'migrations'),
+ *     extension: 'ts'
+ *   }
+ * });
+ *
+ * // Create and use migrator
+ * const migrator = new PostgresObjectionMigrator({
+ *   uri: 'postgresql://localhost:5432/test_db',
+ *   knex: db
+ * });
+ *
+ * const cleanup = await migrator.start();
+ * // Run tests...
+ * await cleanup();
+ * ```
+ */
+declare class PostgresObjectionMigrator extends PostgresMigrator {
+  private options;
+  /**
+   * Creates a new PostgresObjectionMigrator instance.
+   *
+   * @param options - Configuration options
+   * @param options.uri - PostgreSQL connection URI
+   * @param options.knex - Knex database instance configured with migrations
+   */
+  constructor(options: {
+    uri: string;
+    knex: Knex;
+  });
+  /**
+   * Executes Knex migrations to the latest version.
+   * Implements the abstract migrate() method from PostgresMigrator.
+   *
+   * @throws Error if migrations fail to apply
+   * @returns Promise that resolves when all migrations are applied
+   */
+  migrate(): Promise<void>;
+  /**
+   * Rolls back the last batch of migrations.
+   * Useful for testing migration rollback scenarios.
+   *
+   * @returns Promise that resolves when rollback is complete
+   */
+  rollback(): Promise<void>;
+  /**
+   * Gets the current migration status.
+   * Returns information about completed and pending migrations.
+   *
+   * @returns Promise with migration status information
+   */
+  status(): Promise<{
+    completed: string[];
+    pending: string[];
+  }>;
+}
+//#endregion
+export { PostgresObjectionMigrator };

package/dist/PostgresObjectionMigrator-CZHHcCOv.d.cts

@@ -0,0 +1,77 @@
+import { PostgresMigrator } from "./PostgresMigrator-D5UkK1_K.cjs";
+import { Knex } from "knex";
+
+//#region src/PostgresObjectionMigrator.d.ts
+
+/**
+ * PostgreSQL migrator implementation for Objection.js ORM with Knex.
+ * Extends PostgresMigrator to provide Knex-specific migration functionality.
+ * Automatically creates test databases and applies migrations for testing environments.
+ *
+ * @example
+ * ```typescript
+ * import knex from 'knex';
+ * import { PostgresObjectionMigrator } from '@geekmidas/testkit';
+ *
+ * // Create Knex instance
+ * const db = knex({
+ *   client: 'pg',
+ *   connection: uri,
+ *   migrations: {
+ *     directory: path.join(__dirname, 'migrations'),
+ *     extension: 'ts'
+ *   }
+ * });
+ *
+ * // Create and use migrator
+ * const migrator = new PostgresObjectionMigrator({
+ *   uri: 'postgresql://localhost:5432/test_db',
+ *   knex: db
+ * });
+ *
+ * const cleanup = await migrator.start();
+ * // Run tests...
+ * await cleanup();
+ * ```
+ */
+declare class PostgresObjectionMigrator extends PostgresMigrator {
+  private options;
+  /**
+   * Creates a new PostgresObjectionMigrator instance.
+   *
+   * @param options - Configuration options
+   * @param options.uri - PostgreSQL connection URI
+   * @param options.knex - Knex database instance configured with migrations
+   */
+  constructor(options: {
+    uri: string;
+    knex: Knex;
+  });
+  /**
+   * Executes Knex migrations to the latest version.
+   * Implements the abstract migrate() method from PostgresMigrator.
+   *
+   * @throws Error if migrations fail to apply
+   * @returns Promise that resolves when all migrations are applied
+   */
+  migrate(): Promise<void>;
+  /**
+   * Rolls back the last batch of migrations.
+   * Useful for testing migration rollback scenarios.
+   *
+   * @returns Promise that resolves when rollback is complete
+   */
+  rollback(): Promise<void>;
+  /**
+   * Gets the current migration status.
+   * Returns information about completed and pending migrations.
+   *
+   * @returns Promise with migration status information
+   */
+  status(): Promise<{
+    completed: string[];
+    pending: string[];
+  }>;
+}
+//#endregion
+export { PostgresObjectionMigrator };

package/dist/{PostgresObjectionMigrator-DydSgYFv.mjs → PostgresObjectionMigrator-G4h5FLvU.mjs}

@@ -1,4 +1,4 @@
-import { PostgresMigrator } from "./PostgresMigrator-BzqksJcW.mjs";
+import { PostgresMigrator } from "./PostgresMigrator-DxPC_gGu.mjs";
 
 //#region src/PostgresObjectionMigrator.ts
 /**

package/dist/PostgresObjectionMigrator.cjs

@@ -1,4 +1,4 @@
-require('./PostgresMigrator-BtAWdLss.cjs');
-const require_PostgresObjectionMigrator = require('./PostgresObjectionMigrator-B88aTT0m.cjs');
+require('./PostgresMigrator-DFcNdCvD.cjs');
+const require_PostgresObjectionMigrator = require('./PostgresObjectionMigrator-BG6ymgnt.cjs');
 
 exports.PostgresObjectionMigrator = require_PostgresObjectionMigrator.PostgresObjectionMigrator;

package/dist/PostgresObjectionMigrator.d.cts

@@ -0,0 +1,3 @@
+import "./PostgresMigrator-D5UkK1_K.cjs";
+import { PostgresObjectionMigrator } from "./PostgresObjectionMigrator-CZHHcCOv.cjs";
+export { PostgresObjectionMigrator };

package/dist/PostgresObjectionMigrator.d.mts

@@ -0,0 +1,3 @@
+import "./PostgresMigrator-BlvuQl7d.mjs";
+import { PostgresObjectionMigrator } from "./PostgresObjectionMigrator-C69n7vzr.mjs";
+export { PostgresObjectionMigrator };

package/dist/PostgresObjectionMigrator.mjs

@@ -1,4 +1,4 @@
-import "./PostgresMigrator-BzqksJcW.mjs";
-import { PostgresObjectionMigrator } from "./PostgresObjectionMigrator-DydSgYFv.mjs";
+import "./PostgresMigrator-DxPC_gGu.mjs";
+import { PostgresObjectionMigrator } from "./PostgresObjectionMigrator-G4h5FLvU.mjs";
 
 export { PostgresObjectionMigrator };

package/dist/VitestKyselyTransactionIsolator-ClCazkBO.d.mts

@@ -0,0 +1,56 @@
+import { IsolationLevel, VitestPostgresTransactionIsolator } from "./VitestTransactionIsolator-Xqyjlmw6.mjs";
+import { Kysely, Transaction } from "kysely";
+
+//#region src/VitestKyselyTransactionIsolator.d.ts
+
+/**
+ * Kysely-specific implementation of the Vitest transaction isolator.
+ * Provides automatic transaction rollback for test isolation using Kysely's transaction API.
+ * Each test runs within a database transaction that is rolled back after completion,
+ * ensuring a clean state between tests without the overhead of recreating data.
+ *
+ * @template Database - The database schema type
+ *
+ * @example
+ * ```typescript
+ * import { VitestKyselyTransactionIsolator } from '@geekmidas/testkit';
+ * import { db } from './database';
+ *
+ * // Create isolator instance
+ * const isolator = new VitestKyselyTransactionIsolator<Database>();
+ *
+ * // In your test setup
+ * beforeEach(async () => {
+ *   await isolator.start(db);
+ * });
+ *
+ * afterEach(async () => {
+ *   await isolator.rollback();
+ * });
+ *
+ * // Tests run in isolated transactions
+ * it('should create user', async () => {
+ *   const user = await db.insertInto('users')
+ *     .values({ name: 'Test User' })
+ *     .returningAll()
+ *     .executeTakeFirst();
+ *
+ *   expect(user).toBeDefined();
+ *   // This data will be rolled back after the test
+ * });
+ * ```
+ */
+declare class VitestKyselyTransactionIsolator<Database> extends VitestPostgresTransactionIsolator<Kysely<Database>, Transaction<Database>> {
+  /**
+   * Creates a Kysely transaction with the specified isolation level.
+   * Implements the abstract transact method from VitestPostgresTransactionIsolator.
+   *
+   * @param conn - The Kysely database connection
+   * @param level - The transaction isolation level
+   * @param fn - The function to execute within the transaction
+   * @returns Promise that resolves when the transaction completes
+   */
+  transact(conn: Kysely<Database>, level: IsolationLevel, fn: (trx: Transaction<Database>) => Promise<void>): Promise<void>;
+}
+//#endregion
+export { VitestKyselyTransactionIsolator };

package/dist/VitestKyselyTransactionIsolator-UE1J-UoP.d.cts

@@ -0,0 +1,56 @@
+import { IsolationLevel, VitestPostgresTransactionIsolator } from "./VitestTransactionIsolator-DHf2MxmC.cjs";
+import { Kysely, Transaction } from "kysely";
+
+//#region src/VitestKyselyTransactionIsolator.d.ts
+
+/**
+ * Kysely-specific implementation of the Vitest transaction isolator.
+ * Provides automatic transaction rollback for test isolation using Kysely's transaction API.
+ * Each test runs within a database transaction that is rolled back after completion,
+ * ensuring a clean state between tests without the overhead of recreating data.
+ *
+ * @template Database - The database schema type
+ *
+ * @example
+ * ```typescript
+ * import { VitestKyselyTransactionIsolator } from '@geekmidas/testkit';
+ * import { db } from './database';
+ *
+ * // Create isolator instance
+ * const isolator = new VitestKyselyTransactionIsolator<Database>();
+ *
+ * // In your test setup
+ * beforeEach(async () => {
+ *   await isolator.start(db);
+ * });
+ *
+ * afterEach(async () => {
+ *   await isolator.rollback();
+ * });
+ *
+ * // Tests run in isolated transactions
+ * it('should create user', async () => {
+ *   const user = await db.insertInto('users')
+ *     .values({ name: 'Test User' })
+ *     .returningAll()
+ *     .executeTakeFirst();
+ *
+ *   expect(user).toBeDefined();
+ *   // This data will be rolled back after the test
+ * });
+ * ```
+ */
+declare class VitestKyselyTransactionIsolator<Database> extends VitestPostgresTransactionIsolator<Kysely<Database>, Transaction<Database>> {
+  /**
+   * Creates a Kysely transaction with the specified isolation level.
+   * Implements the abstract transact method from VitestPostgresTransactionIsolator.
+   *
+   * @param conn - The Kysely database connection
+   * @param level - The transaction isolation level
+   * @param fn - The function to execute within the transaction
+   * @returns Promise that resolves when the transaction completes
+   */
+  transact(conn: Kysely<Database>, level: IsolationLevel, fn: (trx: Transaction<Database>) => Promise<void>): Promise<void>;
+}
+//#endregion
+export { VitestKyselyTransactionIsolator };

package/dist/VitestKyselyTransactionIsolator.d.cts

@@ -0,0 +1,3 @@
+import "./VitestTransactionIsolator-DHf2MxmC.cjs";
+import { VitestKyselyTransactionIsolator } from "./VitestKyselyTransactionIsolator-UE1J-UoP.cjs";
+export { VitestKyselyTransactionIsolator };

package/dist/VitestKyselyTransactionIsolator.d.mts

@@ -0,0 +1,3 @@
+import "./VitestTransactionIsolator-Xqyjlmw6.mjs";
+import { VitestKyselyTransactionIsolator } from "./VitestKyselyTransactionIsolator-ClCazkBO.mjs";
+export { VitestKyselyTransactionIsolator };

package/dist/VitestObjectionTransactionIsolator-CO2nTi9r.d.cts

@@ -0,0 +1,57 @@
+import { IsolationLevel, VitestPostgresTransactionIsolator } from "./VitestTransactionIsolator-DHf2MxmC.cjs";
+import { Knex } from "knex";
+
+//#region src/VitestObjectionTransactionIsolator.d.ts
+
+/**
+ * Objection.js-specific implementation of the Vitest transaction isolator.
+ * Provides automatic transaction rollback for test isolation using Objection.js and Knex transaction API.
+ * Each test runs within a database transaction that is rolled back after completion,
+ * ensuring a clean state between tests without the overhead of recreating data.
+ *
+ * @example
+ * ```typescript
+ * import { VitestObjectionTransactionIsolator } from '@geekmidas/testkit';
+ * import { knex } from './database';
+ * import { User } from './models';
+ * import { test } from 'vitest';
+ *
+ * // Create isolator instance
+ * const isolator = new VitestObjectionTransactionIsolator(test);
+ *
+ * // Use with wrapped test API
+ * const isolatedTest = isolator.wrapVitestWithTransaction(knex);
+ *
+ * isolatedTest('should create user', async ({ trx }) => {
+ *   const user = await User.query(trx)
+ *     .insert({ name: 'Test User' });
+ *
+ *   expect(user).toBeDefined();
+ *   // This data will be rolled back after the test
+ * });
+ * ```
+ */
+declare class VitestObjectionTransactionIsolator extends VitestPostgresTransactionIsolator<Knex, Knex.Transaction> {
+  /**
+   * Creates a Knex transaction with the specified isolation level.
+   * Implements the abstract transact method from VitestPostgresTransactionIsolator.
+   * This transaction can be used with Objection.js models via Model.query(trx).
+   *
+   * @param conn - The Knex database connection
+   * @param level - The transaction isolation level
+   * @param fn - The function to execute within the transaction
+   * @returns Promise that resolves when the transaction completes
+   *
+   * @example
+   * ```typescript
+   * await isolator.transact(knex, IsolationLevel.REPEATABLE_READ, async (trx) => {
+   *   // Use transaction with Objection models
+   *   await User.query(trx).insert({ name: 'Test' });
+   *   await Post.query(trx).where('userId', user.id).delete();
+   * });
+   * ```
+   */
+  transact(conn: Knex, level: IsolationLevel, fn: (trx: Knex.Transaction) => Promise<void>): Promise<void>;
+}
+//#endregion
+export { VitestObjectionTransactionIsolator };

package/dist/VitestObjectionTransactionIsolator-D264iuPy.d.mts

@@ -0,0 +1,57 @@
+import { IsolationLevel, VitestPostgresTransactionIsolator } from "./VitestTransactionIsolator-Xqyjlmw6.mjs";
+import { Knex } from "knex";
+
+//#region src/VitestObjectionTransactionIsolator.d.ts
+
+/**
+ * Objection.js-specific implementation of the Vitest transaction isolator.
+ * Provides automatic transaction rollback for test isolation using Objection.js and Knex transaction API.
+ * Each test runs within a database transaction that is rolled back after completion,
+ * ensuring a clean state between tests without the overhead of recreating data.
+ *
+ * @example
+ * ```typescript
+ * import { VitestObjectionTransactionIsolator } from '@geekmidas/testkit';
+ * import { knex } from './database';
+ * import { User } from './models';
+ * import { test } from 'vitest';
+ *
+ * // Create isolator instance
+ * const isolator = new VitestObjectionTransactionIsolator(test);
+ *
+ * // Use with wrapped test API
+ * const isolatedTest = isolator.wrapVitestWithTransaction(knex);
+ *
+ * isolatedTest('should create user', async ({ trx }) => {
+ *   const user = await User.query(trx)
+ *     .insert({ name: 'Test User' });
+ *
+ *   expect(user).toBeDefined();
+ *   // This data will be rolled back after the test
+ * });
+ * ```
+ */
+declare class VitestObjectionTransactionIsolator extends VitestPostgresTransactionIsolator<Knex, Knex.Transaction> {
+  /**
+   * Creates a Knex transaction with the specified isolation level.
+   * Implements the abstract transact method from VitestPostgresTransactionIsolator.
+   * This transaction can be used with Objection.js models via Model.query(trx).
+   *
+   * @param conn - The Knex database connection
+   * @param level - The transaction isolation level
+   * @param fn - The function to execute within the transaction
+   * @returns Promise that resolves when the transaction completes
+   *
+   * @example
+   * ```typescript
+   * await isolator.transact(knex, IsolationLevel.REPEATABLE_READ, async (trx) => {
+   *   // Use transaction with Objection models
+   *   await User.query(trx).insert({ name: 'Test' });
+   *   await Post.query(trx).where('userId', user.id).delete();
+   * });
+   * ```
+   */
+  transact(conn: Knex, level: IsolationLevel, fn: (trx: Knex.Transaction) => Promise<void>): Promise<void>;
+}
+//#endregion
+export { VitestObjectionTransactionIsolator };

package/dist/VitestObjectionTransactionIsolator.d.cts

@@ -0,0 +1,3 @@
+import "./VitestTransactionIsolator-DHf2MxmC.cjs";
+import { VitestObjectionTransactionIsolator } from "./VitestObjectionTransactionIsolator-CO2nTi9r.cjs";
+export { VitestObjectionTransactionIsolator };

package/dist/VitestObjectionTransactionIsolator.d.mts

@@ -0,0 +1,3 @@
+import "./VitestTransactionIsolator-Xqyjlmw6.mjs";
+import { VitestObjectionTransactionIsolator } from "./VitestObjectionTransactionIsolator-D264iuPy.mjs";
+export { VitestObjectionTransactionIsolator };

package/dist/VitestTransactionIsolator-DHf2MxmC.d.cts

@@ -0,0 +1,118 @@
+import { TestAPI } from "vitest";
+
+//#region src/VitestTransactionIsolator.d.ts
+
+/**
+ * Type definition for test fixtures that provide transaction access.
+ * Used with Vitest's test.extend() API to inject transactions into tests.
+ *
+ * @template Transaction - The transaction type specific to the database driver
+ */
+interface DatabaseFixtures<Transaction> {
+  /**
+   * The database transaction available to the test.
+   * All database operations should use this transaction to ensure proper rollback.
+   */
+  trx: Transaction;
+}
+/**
+ * PostgreSQL transaction isolation levels.
+ * Controls the visibility of concurrent transactions.
+ *
+ * @see https://www.postgresql.org/docs/current/transaction-iso.html
+ */
+declare enum IsolationLevel {
+  /**
+   * Lowest isolation level. Allows dirty reads.
+   * Not recommended for testing.
+   */
+  READ_UNCOMMITTED = "READ UNCOMMITTED",
+  /**
+   * Default PostgreSQL isolation level.
+   * Prevents dirty reads but allows non-repeatable reads.
+   */
+  READ_COMMITTED = "READ COMMITTED",
+  /**
+   * Prevents dirty reads and non-repeatable reads.
+   * Recommended for most test scenarios.
+   */
+  REPEATABLE_READ = "REPEATABLE READ",
+  /**
+   * Highest isolation level. Prevents all phenomena.
+   * May cause performance overhead in tests.
+   */
+  SERIALIZABLE = "SERIALIZABLE",
+}
+/**
+ * Abstract base class for implementing database transaction isolation in Vitest tests.
+ * Provides automatic transaction rollback after each test to maintain test isolation.
+ * Subclasses must implement the transact() method for their specific database driver.
+ *
+ * @template Connection - The database connection type
+ * @template Transaction - The transaction type
+ *
+ * @example
+ * ```typescript
+ * // Implement for your database driver
+ * class MyDatabaseIsolator extends VitestPostgresTransactionIsolator<MyDB, MyTx> {
+ *   async transact(conn: MyDB, level: IsolationLevel, fn: (tx: MyTx) => Promise<void>) {
+ *     await conn.transaction(level, fn);
+ *   }
+ * }
+ *
+ * // Use in tests
+ * const isolator = new MyDatabaseIsolator(test);
+ * const isolatedTest = isolator.wrapVitestWithTransaction(db);
+ *
+ * isolatedTest('should create user', async ({ trx }) => {
+ *   await trx.insert('users', { name: 'Test' });
+ *   // Data is automatically rolled back after test
+ * });
+ * ```
+ */
+declare abstract class VitestPostgresTransactionIsolator<Connection, Transaction> {
+  private readonly api;
+  /**
+   * Abstract method to create a transaction with the specified isolation level.
+   * Must be implemented by subclasses for specific database drivers.
+   *
+   * @param conn - The database connection
+   * @param isolationLevel - The transaction isolation level
+   * @param fn - The function to execute within the transaction
+   * @returns Promise that resolves when the transaction completes
+   */
+  abstract transact(conn: Connection, isolationLevel: IsolationLevel, fn: (trx: Transaction) => Promise<void>): Promise<void>;
+  /**
+   * Creates a new VitestPostgresTransactionIsolator instance.
+   *
+   * @param api - The Vitest test API (usually the `test` export from vitest)
+   */
+  constructor(api: TestAPI);
+  /**
+   * Creates a wrapped version of Vitest's test API that provides transaction isolation.
+   * Each test will run within a database transaction that is automatically rolled back.
+   *
+   * @param conn - The database connection to use
+   * @param setup - Optional setup function to run within the transaction before each test
+   * @param level - The transaction isolation level (defaults to REPEATABLE_READ)
+   * @returns A wrapped test API with transaction support
+   *
+   * @example
+   * ```typescript
+   * const isolatedTest = isolator.wrapVitestWithTransaction(db, async (trx) => {
+   *   // Optional setup: create common test data
+   *   await trx.insert('settings', { key: 'test', value: 'true' });
+   * });
+   *
+   * isolatedTest('test with transaction', async ({ trx }) => {
+   *   const user = await trx.insert('users', { name: 'Test' });
+   *   expect(user).toBeDefined();
+   * });
+   * ```
+   */
+  wrapVitestWithTransaction(conn: Connection, setup?: (trx: Transaction) => Promise<void>, level?: IsolationLevel): TestAPI<{
+    trx: Transaction;
+  }>;
+}
+//#endregion
+export { DatabaseFixtures, IsolationLevel, VitestPostgresTransactionIsolator };

package/dist/VitestTransactionIsolator-Xqyjlmw6.d.mts

@@ -0,0 +1,118 @@
+import { TestAPI } from "vitest";
+
+//#region src/VitestTransactionIsolator.d.ts
+
+/**
+ * Type definition for test fixtures that provide transaction access.
+ * Used with Vitest's test.extend() API to inject transactions into tests.
+ *
+ * @template Transaction - The transaction type specific to the database driver
+ */
+interface DatabaseFixtures<Transaction> {
+  /**
+   * The database transaction available to the test.
+   * All database operations should use this transaction to ensure proper rollback.
+   */
+  trx: Transaction;
+}
+/**
+ * PostgreSQL transaction isolation levels.
+ * Controls the visibility of concurrent transactions.
+ *
+ * @see https://www.postgresql.org/docs/current/transaction-iso.html
+ */
+declare enum IsolationLevel {
+  /**
+   * Lowest isolation level. Allows dirty reads.
+   * Not recommended for testing.
+   */
+  READ_UNCOMMITTED = "READ UNCOMMITTED",
+  /**
+   * Default PostgreSQL isolation level.
+   * Prevents dirty reads but allows non-repeatable reads.
+   */
+  READ_COMMITTED = "READ COMMITTED",
+  /**
+   * Prevents dirty reads and non-repeatable reads.
+   * Recommended for most test scenarios.
+   */
+  REPEATABLE_READ = "REPEATABLE READ",
+  /**
+   * Highest isolation level. Prevents all phenomena.
+   * May cause performance overhead in tests.
+   */
+  SERIALIZABLE = "SERIALIZABLE",
+}
+/**
+ * Abstract base class for implementing database transaction isolation in Vitest tests.
+ * Provides automatic transaction rollback after each test to maintain test isolation.
+ * Subclasses must implement the transact() method for their specific database driver.
+ *
+ * @template Connection - The database connection type
+ * @template Transaction - The transaction type
+ *
+ * @example
+ * ```typescript
+ * // Implement for your database driver
+ * class MyDatabaseIsolator extends VitestPostgresTransactionIsolator<MyDB, MyTx> {
+ *   async transact(conn: MyDB, level: IsolationLevel, fn: (tx: MyTx) => Promise<void>) {
+ *     await conn.transaction(level, fn);
+ *   }
+ * }
+ *
+ * // Use in tests
+ * const isolator = new MyDatabaseIsolator(test);
+ * const isolatedTest = isolator.wrapVitestWithTransaction(db);
+ *
+ * isolatedTest('should create user', async ({ trx }) => {
+ *   await trx.insert('users', { name: 'Test' });
+ *   // Data is automatically rolled back after test
+ * });
+ * ```
+ */
+declare abstract class VitestPostgresTransactionIsolator<Connection, Transaction> {
+  private readonly api;
+  /**
+   * Abstract method to create a transaction with the specified isolation level.
+   * Must be implemented by subclasses for specific database drivers.
+   *
+   * @param conn - The database connection
+   * @param isolationLevel - The transaction isolation level
+   * @param fn - The function to execute within the transaction
+   * @returns Promise that resolves when the transaction completes
+   */
+  abstract transact(conn: Connection, isolationLevel: IsolationLevel, fn: (trx: Transaction) => Promise<void>): Promise<void>;
+  /**
+   * Creates a new VitestPostgresTransactionIsolator instance.
+   *
+   * @param api - The Vitest test API (usually the `test` export from vitest)
+   */
+  constructor(api: TestAPI);
+  /**
+   * Creates a wrapped version of Vitest's test API that provides transaction isolation.
+   * Each test will run within a database transaction that is automatically rolled back.
+   *
+   * @param conn - The database connection to use
+   * @param setup - Optional setup function to run within the transaction before each test
+   * @param level - The transaction isolation level (defaults to REPEATABLE_READ)
+   * @returns A wrapped test API with transaction support
+   *
+   * @example
+   * ```typescript
+   * const isolatedTest = isolator.wrapVitestWithTransaction(db, async (trx) => {
+   *   // Optional setup: create common test data
+   *   await trx.insert('settings', { key: 'test', value: 'true' });
+   * });
+   *
+   * isolatedTest('test with transaction', async ({ trx }) => {
+   *   const user = await trx.insert('users', { name: 'Test' });
+   *   expect(user).toBeDefined();
+   * });
+   * ```
+   */
+  wrapVitestWithTransaction(conn: Connection, setup?: (trx: Transaction) => Promise<void>, level?: IsolationLevel): TestAPI<{
+    trx: Transaction;
+  }>;
+}
+//#endregion
+export { DatabaseFixtures, IsolationLevel, VitestPostgresTransactionIsolator };

package/dist/VitestTransactionIsolator.d.cts

@@ -0,0 +1,2 @@
+import { DatabaseFixtures, IsolationLevel, VitestPostgresTransactionIsolator } from "./VitestTransactionIsolator-DHf2MxmC.cjs";
+export { DatabaseFixtures, IsolationLevel, VitestPostgresTransactionIsolator };