@geekmidas/testkit 0.1.0 → 0.2.0

package/src/__tests__/KyselyFactory.spec.ts

@@ -7,11 +7,10 @@ import { createKyselyDb } from '../helpers';
 import { wrapVitestKyselyTransaction } from '../kysely';
 
 const db = () => createKyselyDb<TestDatabase>(TEST_DATABASE_CONFIG);
-const itWithTransaction = wrapVitestKyselyTransaction<TestDatabase>(
-  it,
-  db,
-  createTestTables,
-);
+const itWithTransaction = wrapVitestKyselyTransaction<TestDatabase>(it, {
+  connection: db,
+  setup: createTestTables,
+});
 
 const int8TypeId = 20;
 pg.types.setTypeParser(int8TypeId, (val) => {

package/src/__tests__/ObjectionFactory.spec.ts

@@ -37,11 +37,10 @@ class Comment extends Model {
   user_id!: string;
 }
 
-const it = wrapVitestObjectionTransaction(
-  test,
-  createKnexDb,
-  createTestTablesKnex,
-);
+const it = wrapVitestObjectionTransaction(test, {
+  connection: createKnexDb,
+  setup: createTestTablesKnex,
+});
 describe('ObjectionFactory', () => {
   it('should create an ObjectionFactory instance', ({ trx }) => {
     const builders = {};

package/src/__tests__/VitestObjectionTransactionIsolator.spec.ts

@@ -108,9 +108,12 @@ class Comment extends Model {
 // Create database connection
 
 // Create wrapped test with transaction isolation
-const it = wrapVitestObjectionTransaction(base, createKnexDb, async (trx) => {
-  // Create tables in the transaction
-  await createTestTablesKnex(trx);
+const it = wrapVitestObjectionTransaction(base, {
+  connection: createKnexDb,
+  setup: async (trx) => {
+    // Create tables in the transaction
+    await createTestTablesKnex(trx);
+  },
 });
 
 describe('VitestObjectionTransactionIsolator', () => {

package/src/__tests__/integration.spec.ts

@@ -6,11 +6,10 @@ import { createKyselyDb } from '../helpers';
 import { extendWithFixtures, wrapVitestKyselyTransaction } from '../kysely';
 
 const db = () => createKyselyDb<TestDatabase>(TEST_DATABASE_CONFIG);
-const it = wrapVitestKyselyTransaction<TestDatabase>(
-  base,
-  db,
-  createTestTables,
-);
+const it = wrapVitestKyselyTransaction<TestDatabase>(base, {
+  connection: db,
+  setup: createTestTables,
+});
 describe('Testkit Integration Tests', () => {
   beforeAll(async () => {});
   describe('Complex Factory Scenarios', () => {
@@ -481,11 +480,10 @@ describe('extendWithFixtures', () => {
   };
 
   // Create base test with transaction
-  const baseTest = wrapVitestKyselyTransaction<TestDatabase>(
-    base,
-    db,
-    createTestTables,
-  );
+  const baseTest = wrapVitestKyselyTransaction<TestDatabase>(base, {
+    connection: db,
+    setup: createTestTables,
+  });
 
   // Extend with factory fixture
   const itWithFactory = extendWithFixtures<

package/src/kysely.ts

@@ -4,7 +4,7 @@ import { VitestKyselyTransactionIsolator } from './VitestKyselyTransactionIsolat
 import {
   type DatabaseConnection,
   type FixtureCreators,
-  IsolationLevel,
+  type IsolationLevel,
   extendWithFixtures as baseExtendWithFixtures,
 } from './VitestTransactionIsolator';
 
@@ -17,7 +17,30 @@ export { KyselyFactory } from './KyselyFactory';
 export { PostgresKyselyMigrator } from './PostgresKyselyMigrator';
 export { VitestKyselyTransactionIsolator } from './VitestKyselyTransactionIsolator';
 export { IsolationLevel } from './VitestTransactionIsolator';
-export type { FixtureCreators } from './VitestTransactionIsolator';
+export type {
+  DatabaseFixtures,
+  ExtendedDatabaseFixtures,
+  FixtureCreators,
+  TestWithExtendedFixtures,
+  TransactionWrapperOptions,
+} from './VitestTransactionIsolator';
+
+/**
+ * Kysely-specific options for transaction wrapping.
+ */
+export interface KyselyTransactionOptions<
+  Database,
+  Extended extends Record<string, unknown> = {},
+> {
+  /** Function that creates or returns a Kysely database instance */
+  connection: DatabaseConnection<Kysely<Database>>;
+  /** Optional setup function to run within the transaction before each test */
+  setup?: (trx: Transaction<Database>) => Promise<void>;
+  /** Transaction isolation level (defaults to REPEATABLE_READ) */
+  isolationLevel?: IsolationLevel;
+  /** Additional fixtures that depend on the transaction */
+  fixtures?: FixtureCreators<Transaction<Database>, Extended>;
+}
 
 // Re-export faker and FakerFactory for type portability in declaration files
 export { faker, type FakerFactory } from './faker';
@@ -28,10 +51,9 @@ export { faker, type FakerFactory } from './faker';
  * This ensures tests don't affect each other's data and run faster than truncating tables.
  *
  * @template Database - The database schema type
+ * @template Extended - Additional fixtures to provide
  * @param api - The Vitest test API (usually `test` from vitest)
- * @param db - The Kysely database instance
- * @param setup - Optional setup function to run before each test in the transaction
- * @param level - Transaction isolation level (defaults to REPEATABLE_READ)
+ * @param options - Configuration options for transaction wrapping
  * @returns A wrapped test API that provides transaction isolation
  *
  * @example
@@ -41,7 +63,9 @@ export { faker, type FakerFactory } from './faker';
  * import { db } from './database';
  *
  * // Create isolated test with automatic rollback
- * const isolatedTest = wrapVitestKyselyTransaction(test, db);
+ * const isolatedTest = wrapVitestKyselyTransaction(test, {
+ *   connection: db,
+ * });
  *
  * // Use in tests - each test gets its own transaction
  * isolatedTest('should create user', async ({ trx }) => {
@@ -52,41 +76,29 @@ export { faker, type FakerFactory } from './faker';
  *     .executeTakeFirst();
  *
  *   expect(user).toBeDefined();
- *   // User is automatically rolled back after test
  * });
  *
- * // With setup function for common test data
- * const testWithSetup = wrapVitestKyselyTransaction(
- *   test,
- *   db,
- *   async (trx) => {
- *     // Create common test data
- *     await trx.insertInto('settings')
- *       .values({ key: 'test_mode', value: 'true' })
- *       .execute();
- *   }
- * );
- *
- * testWithSetup('should have test settings', async ({ trx }) => {
- *   const setting = await trx
- *     .selectFrom('settings')
- *     .where('key', '=', 'test_mode')
- *     .selectAll()
- *     .executeTakeFirst();
+ * // With fixtures for factories
+ * const it = wrapVitestKyselyTransaction<DB, { factory: Factory }>(test, {
+ *   connection: db,
+ *   fixtures: {
+ *     factory: (trx) => new Factory(trx),
+ *   },
+ * });
  *
- *   expect(setting?.value).toBe('true');
+ * it('should create user with factory', async ({ trx, factory }) => {
+ *   const user = await factory.insert('user', { name: 'Test' });
+ *   expect(user.id).toBeDefined();
  * });
  * ```
  */
-export function wrapVitestKyselyTransaction<Database>(
-  api: TestAPI,
-  connection: DatabaseConnection<Kysely<Database>>,
-  setup?: (trx: Transaction<Database>) => Promise<void>,
-  level: IsolationLevel = IsolationLevel.REPEATABLE_READ,
-) {
+export function wrapVitestKyselyTransaction<
+  Database,
+  Extended extends Record<string, unknown> = {},
+>(api: TestAPI, options: KyselyTransactionOptions<Database, Extended>) {
   const wrapper = new VitestKyselyTransactionIsolator<Database>(api);
 
-  return wrapper.wrapVitestWithTransaction(connection, setup, level);
+  return wrapper.wrapVitestWithTransaction(options);
 }
 
 /**
@@ -113,7 +125,10 @@ export function wrapVitestKyselyTransaction<Database>(
  * };
  *
  * // Create base wrapped test
- * const baseTest = wrapVitestKyselyTransaction<DB>(test, db, createTestTables);
+ * const baseTest = wrapVitestKyselyTransaction<DB>(test, {
+ *   connection: db,
+ *   setup: createTestTables,
+ * });
  *
  * // Extend with fixtures - each fixture receives the transaction
  * const it = extendWithFixtures<DB, { factory: KyselyFactory<DB, typeof builders, {}> }>(

package/src/objection.ts

@@ -4,7 +4,7 @@ import { VitestObjectionTransactionIsolator } from './VitestObjectionTransaction
 import {
   type DatabaseConnection,
   type FixtureCreators,
-  IsolationLevel,
+  type IsolationLevel,
   extendWithFixtures as baseExtendWithFixtures,
 } from './VitestTransactionIsolator';
 
@@ -18,7 +18,29 @@ export { ObjectionFactory } from './ObjectionFactory';
 export { VitestObjectionTransactionIsolator } from './VitestObjectionTransactionIsolator';
 export { IsolationLevel } from './VitestTransactionIsolator';
 export { PostgresObjectionMigrator } from './PostgresObjectionMigrator';
-export type { FixtureCreators } from './VitestTransactionIsolator';
+export type {
+  DatabaseFixtures,
+  ExtendedDatabaseFixtures,
+  FixtureCreators,
+  TestWithExtendedFixtures,
+  TransactionWrapperOptions,
+} from './VitestTransactionIsolator';
+
+/**
+ * Objection.js-specific options for transaction wrapping.
+ */
+export interface ObjectionTransactionOptions<
+  Extended extends Record<string, unknown> = {},
+> {
+  /** Function that creates or returns a Knex database connection */
+  connection: DatabaseConnection<Knex>;
+  /** Optional setup function to run within the transaction before each test */
+  setup?: (trx: Knex.Transaction) => Promise<void>;
+  /** Transaction isolation level (defaults to REPEATABLE_READ) */
+  isolationLevel?: IsolationLevel;
+  /** Additional fixtures that depend on the transaction */
+  fixtures?: FixtureCreators<Knex.Transaction, Extended>;
+}
 
 // Re-export faker and FakerFactory for type portability in declaration files
 export { faker, type FakerFactory } from './faker';
@@ -28,10 +50,9 @@ export { faker, type FakerFactory } from './faker';
  * Each test runs in an isolated database transaction that is rolled back after completion.
  * This ensures tests don't affect each other's data and run faster than truncating tables.
  *
+ * @template Extended - Additional fixtures to provide
  * @param api - The Vitest test API (usually `test` from vitest)
- * @param conn - The Knex database connection instance
- * @param setup - Optional setup function to run before each test in the transaction
- * @param level - Transaction isolation level (defaults to REPEATABLE_READ)
+ * @param options - Configuration options for transaction wrapping
  * @returns A wrapped test API that provides transaction isolation
  *
  * @example
@@ -39,10 +60,12 @@ export { faker, type FakerFactory } from './faker';
  * import { test } from 'vitest';
  * import { wrapVitestObjectionTransaction } from '@geekmidas/testkit/objection';
  * import { knex } from './database';
- * import { User, Post } from './models';
+ * import { User } from './models';
  *
  * // Create isolated test with automatic rollback
- * const isolatedTest = wrapVitestObjectionTransaction(test, knex);
+ * const isolatedTest = wrapVitestObjectionTransaction(test, {
+ *   connection: knex,
+ * });
  *
  * // Use in tests - each test gets its own transaction
  * isolatedTest('should create user', async ({ trx }) => {
@@ -50,59 +73,28 @@ export { faker, type FakerFactory } from './faker';
  *     .insert({ name: 'Test User', email: 'test@example.com' });
  *
  *   expect(user).toBeDefined();
- *   // User is automatically rolled back after test
  * });
  *
- * // With setup function for common test data
- * const testWithSetup = wrapVitestObjectionTransaction(
- *   test,
- *   knex,
- *   async (trx) => {
- *     // Create common test data
- *     await knex('settings')
- *       .transacting(trx)
- *       .insert({ key: 'test_mode', value: 'true' });
- *   }
- * );
- *
- * testWithSetup('should have test settings', async ({ trx }) => {
- *   const setting = await knex('settings')
- *     .transacting(trx)
- *     .where('key', 'test_mode')
- *     .first();
- *
- *   expect(setting?.value).toBe('true');
+ * // With fixtures for factories
+ * const it = wrapVitestObjectionTransaction<{ factory: Factory }>(test, {
+ *   connection: knex,
+ *   fixtures: {
+ *     factory: (trx) => new Factory(trx),
+ *   },
  * });
  *
- * // Example with factory and transaction
- * const isolatedTest = wrapVitestObjectionTransaction(test, knex);
- * const factory = new ObjectionFactory(builders, seeds, knex);
- *
- * isolatedTest('creates related data', async ({ trx }) => {
- *   // Factory can use the transaction
- *   const user = await User.query(trx).insert({ name: 'Author' });
- *   const posts = await Post.query(trx).insert([
- *     { title: 'Post 1', userId: user.id },
- *     { title: 'Post 2', userId: user.id }
- *   ]);
- *
- *   const userWithPosts = await User.query(trx)
- *     .findById(user.id)
- *     .withGraphFetched('posts');
- *
- *   expect(userWithPosts.posts).toHaveLength(2);
+ * it('should create user with factory', async ({ trx, factory }) => {
+ *   const user = await factory.insert('user', { name: 'Test' });
+ *   expect(user.id).toBeDefined();
  * });
  * ```
  */
-export function wrapVitestObjectionTransaction(
-  api: TestAPI,
-  conn: DatabaseConnection<Knex>,
-  setup?: (trx: Knex.Transaction) => Promise<void>,
-  level: IsolationLevel = IsolationLevel.REPEATABLE_READ,
-) {
+export function wrapVitestObjectionTransaction<
+  Extended extends Record<string, unknown> = {},
+>(api: TestAPI, options: ObjectionTransactionOptions<Extended>) {
   const wrapper = new VitestObjectionTransactionIsolator(api);
 
-  return wrapper.wrapVitestWithTransaction(conn, setup, level);
+  return wrapper.wrapVitestWithTransaction(options);
 }
 
 /**
@@ -129,7 +121,10 @@ export function wrapVitestObjectionTransaction(
  * };
  *
  * // Create base wrapped test
- * const baseTest = wrapVitestObjectionTransaction(test, knex, createTestTables);
+ * const baseTest = wrapVitestObjectionTransaction(test, {
+ *   connection: knex,
+ *   setup: createTestTables,
+ * });
  *
  * // Extend with fixtures - each fixture receives the transaction
  * const it = extendWithFixtures<{ factory: ObjectionFactory<typeof builders, {}> }>(

package/dist/VitestTransactionIsolator-BIaMs4c2.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"VitestTransactionIsolator-BIaMs4c2.mjs","names":["api: TestAPI","createConnection: DatabaseConnection<TConn>","setup?: (trx: Transaction) => Promise<void>","level: IsolationLevel","use: (value: Transaction) => Promise<void>","testError: Error | undefined","wrappedTest: T","fixtures: FixtureCreators<Transaction, Extended>","fixtureDefinitions: Record<string, any>","use: (value: unknown) => Promise<void>"],"sources":["../src/VitestTransactionIsolator.ts"],"sourcesContent":["import type { TestAPI } from 'vitest';\n\n/**\n * Type definition for test fixtures that provide transaction access.\n * Used with Vitest's test.extend() API to inject transactions into tests.\n *\n * @template Transaction - The transaction type specific to the database driver\n * @template Extended - Additional context properties provided by the extend function\n */\nexport interface DatabaseFixtures<Transaction, Extended = object> {\n  /**\n   * The database transaction available to the test.\n   * All database operations should use this transaction to ensure proper rollback.\n   */\n  trx: Transaction;\n}\n\n/**\n * Combined fixtures type that merges the base transaction fixture with extended context.\n */\nexport type ExtendedDatabaseFixtures<\n  Transaction,\n  Extended = object,\n> = DatabaseFixtures<Transaction> & Extended;\n\n/**\n * Function type for extending test context with additional properties.\n * Receives the transaction and returns additional context to be merged with { trx }.\n *\n * @template Transaction - The transaction type\n * @template Extended - The type of additional context to provide\n *\n * @example\n * ```typescript\n * const extendContext: ExtendContextFn<Transaction<DB>, { factory: KyselyFactory }> =\n *   (trx) => ({ factory: new KyselyFactory(builders, seeds, trx) });\n * ```\n */\nexport type ExtendContextFn<Transaction, Extended> = (\n  trx: Transaction,\n) => Extended | Promise<Extended>;\n\n/**\n * PostgreSQL transaction isolation levels.\n * Controls the visibility of concurrent transactions.\n *\n * @see https://www.postgresql.org/docs/current/transaction-iso.html\n */\nexport enum IsolationLevel {\n  /**\n   * Lowest isolation level. Allows dirty reads.\n   * Not recommended for testing.\n   */\n  READ_UNCOMMITTED = 'READ UNCOMMITTED',\n  /**\n   * Default PostgreSQL isolation level.\n   * Prevents dirty reads but allows non-repeatable reads.\n   */\n  READ_COMMITTED = 'READ COMMITTED',\n  /**\n   * Prevents dirty reads and non-repeatable reads.\n   * Recommended for most test scenarios.\n   */\n  REPEATABLE_READ = 'REPEATABLE READ',\n  /**\n   * Highest isolation level. Prevents all phenomena.\n   * May cause performance overhead in tests.\n   */\n  SERIALIZABLE = 'SERIALIZABLE',\n}\n\n/**\n * Abstract base class for implementing database transaction isolation in Vitest tests.\n * Provides automatic transaction rollback after each test to maintain test isolation.\n * Subclasses must implement the transact() method for their specific database driver.\n *\n * @template TConn - The database connection type\n * @template Transaction - The transaction type\n *\n * @example\n * ```typescript\n * // Implement for your database driver\n * class MyDatabaseIsolator extends VitestPostgresTransactionIsolator<MyDB, MyTx> {\n *   async transact(conn: MyDB, level: IsolationLevel, fn: (tx: MyTx) => Promise<void>) {\n *     await conn.transaction(level, fn);\n *   }\n * }\n *\n * // Use in tests\n * const isolator = new MyDatabaseIsolator(test);\n * const isolatedTest = isolator.wrapVitestWithTransaction(db);\n *\n * isolatedTest('should create user', async ({ trx }) => {\n *   await trx.insert('users', { name: 'Test' });\n *   // Data is automatically rolled back after test\n * });\n * ```\n */\nexport abstract class VitestPostgresTransactionIsolator<TConn, Transaction> {\n  /**\n   * Abstract method to create a transaction with the specified isolation level.\n   * Must be implemented by subclasses for specific database drivers.\n   *\n   * @param conn - The database connection\n   * @param isolationLevel - The transaction isolation level\n   * @param fn - The function to execute within the transaction\n   * @returns Promise that resolves when the transaction completes\n   */\n  abstract transact(\n    conn: TConn,\n    isolationLevel: IsolationLevel,\n    fn: (trx: Transaction) => Promise<void>,\n  ): Promise<void>;\n\n  abstract destroy(conn: TConn): Promise<void>;\n  /**\n   * Creates a new VitestPostgresTransactionIsolator instance.\n   *\n   * @param api - The Vitest test API (usually the `test` export from vitest)\n   */\n  constructor(private readonly api: TestAPI) {}\n\n  /**\n   * Creates a wrapped version of Vitest's test API that provides transaction isolation.\n   * Each test will run within a database transaction that is automatically rolled back.\n   *\n   * @param conn - The database connection to use\n   * @param setup - Optional setup function to run within the transaction before each test\n   * @param level - The transaction isolation level (defaults to REPEATABLE_READ)\n   * @returns A wrapped test API with transaction support\n   *\n   * @example\n   * ```typescript\n   * const isolatedTest = isolator.wrapVitestWithTransaction(db, async (trx) => {\n   *   // Optional setup: create common test data\n   *   await trx.insert('settings', { key: 'test', value: 'true' });\n   * });\n   *\n   * isolatedTest('test with transaction', async ({ trx }) => {\n   *   const user = await trx.insert('users', { name: 'Test' });\n   *   expect(user).toBeDefined();\n   * });\n   * ```\n   */\n  wrapVitestWithTransaction(\n    createConnection: DatabaseConnection<TConn>,\n    setup?: (trx: Transaction) => Promise<void>,\n    level: IsolationLevel = IsolationLevel.REPEATABLE_READ,\n  ) {\n    return this.api.extend<DatabaseFixtures<Transaction>>({\n      // This fixture automatically provides a transaction to each test\n      trx: async ({}, use: (value: Transaction) => Promise<void>) => {\n        // Create a custom error class for rollback\n        class TestRollback extends Error {\n          constructor() {\n            super('Test rollback');\n            this.name = 'TestRollback';\n          }\n        }\n\n        let testError: Error | undefined;\n        const conn = await createConnection();\n        try {\n          await this.transact(conn, level, async (transaction) => {\n            try {\n              // Provide the transaction to the test\n              await setup?.(transaction);\n              await use(transaction);\n            } catch (error) {\n              // Capture any test errors\n              testError = error as Error;\n            }\n\n            // Always throw to trigger rollback\n            throw new TestRollback();\n          });\n        } catch (error) {\n          // Only rethrow if it's not our rollback error\n          if (!(error instanceof TestRollback)) {\n            throw error;\n          }\n\n          // If the test had an error, throw it now\n          if (testError) {\n            throw testError;\n          }\n        } finally {\n          await this.destroy(conn);\n        }\n      },\n    });\n  }\n}\n\nexport type DatabaseConnectionFn<Conn> = () => Conn | Promise<Conn>;\nexport type DatabaseConnection<Conn> = DatabaseConnectionFn<Conn>;\n\n/**\n * Type for fixture creator functions that depend on the transaction.\n * Each function receives the transaction and returns the fixture value.\n */\nexport type FixtureCreators<\n  Transaction,\n  Extended extends Record<string, unknown>,\n> = {\n  [K in keyof Extended]: (\n    trx: Transaction,\n  ) => Extended[K] | Promise<Extended[K]>;\n};\n\n/**\n * Extends a wrapped test API with additional fixtures that depend on the transaction.\n * This allows composing test context with factories, repositories, or other helpers.\n *\n * @template Transaction - The transaction type\n * @template Extended - The type of additional context to provide\n * @param wrappedTest - The base wrapped test from wrapVitestWithTransaction\n * @param fixtures - Object mapping fixture names to creator functions\n * @returns An extended test API with both trx and the additional fixtures\n *\n * @example\n * ```typescript\n * import { wrapVitestKyselyTransaction, extendWithFixtures } from '@geekmidas/testkit/kysely';\n *\n * // Create base wrapped test\n * const baseTest = wrapVitestKyselyTransaction(test, db, createTestTables);\n *\n * // Extend with fixtures\n * const it = extendWithFixtures(baseTest, {\n *   factory: (trx) => new KyselyFactory(builders, seeds, trx),\n *   userRepo: (trx) => new UserRepository(trx),\n * });\n *\n * // Use in tests - trx and all fixtures are available\n * it('should create user with factory', async ({ trx, factory, userRepo }) => {\n *   const user = await factory.insert('user', { name: 'Test' });\n *   expect(user).toBeDefined();\n * });\n * ```\n */\nexport function extendWithFixtures<\n  Transaction,\n  Extended extends Record<string, unknown>,\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  T extends ReturnType<TestAPI['extend']> = any,\n>(\n  wrappedTest: T,\n  fixtures: FixtureCreators<Transaction, Extended>,\n): T & {\n  <C extends object>(\n    name: string,\n    fn: (\n      context: DatabaseFixtures<Transaction> & Extended & C,\n    ) => Promise<void>,\n  ): void;\n  <C extends object>(\n    name: string,\n    options: object,\n    fn: (\n      context: DatabaseFixtures<Transaction> & Extended & C,\n    ) => Promise<void>,\n  ): void;\n} {\n  // Build fixture definitions for Vitest's extend API\n  const fixtureDefinitions: Record<string, any> = {};\n\n  for (const [key, creator] of Object.entries(fixtures)) {\n    fixtureDefinitions[key] = async (\n      { trx }: { trx: Transaction },\n      use: (value: unknown) => Promise<void>,\n    ) => {\n      const value = await (creator as (trx: Transaction) => unknown)(trx);\n      await use(value);\n    };\n  }\n\n  return (wrappedTest as any).extend(fixtureDefinitions);\n}\n"],"mappings":";;;;;;;AAgDA,IAAY,4DAAL;;;;;AAKL;;;;;AAKA;;;;;AAKA;;;;;AAKA;;AACD;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6BD,IAAsB,oCAAtB,MAA4E;;;;;;CAsB1E,YAA6BA,KAAc;EAAd;CAAgB;;;;;;;;;;;;;;;;;;;;;;;CAwB7C,0BACEC,kBACAC,OACAC,QAAwB,eAAe,iBACvC;AACA,SAAO,KAAK,IAAI,OAAsC,EAEpD,KAAK,OAAO,EAAE,EAAEC,QAA+C;GAE7D,MAAM,qBAAqB,MAAM;IAC/B,cAAc;AACZ,WAAM,gBAAgB;AACtB,UAAK,OAAO;IACb;GACF;GAED,IAAIC;GACJ,MAAM,OAAO,MAAM,kBAAkB;AACrC,OAAI;AACF,UAAM,KAAK,SAAS,MAAM,OAAO,OAAO,gBAAgB;AACtD,SAAI;AAEF,YAAM,QAAQ,YAAY;AAC1B,YAAM,IAAI,YAAY;KACvB,SAAQ,OAAO;AAEd,kBAAY;KACb;AAGD,WAAM,IAAI;IACX,EAAC;GACH,SAAQ,OAAO;AAEd,UAAM,iBAAiB,cACrB,OAAM;AAIR,QAAI,UACF,OAAM;GAET,UAAS;AACR,UAAM,KAAK,QAAQ,KAAK;GACzB;EACF,EACF,EAAC;CACH;AACF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgDD,SAAgB,mBAMdC,aACAC,UAeA;CAEA,MAAMC,qBAA0C,CAAE;AAElD,MAAK,MAAM,CAAC,KAAK,QAAQ,IAAI,OAAO,QAAQ,SAAS,CACnD,oBAAmB,OAAO,OACxB,EAAE,KAA2B,EAC7BC,QACG;EACH,MAAM,QAAQ,MAAM,AAAC,QAA0C,IAAI;AACnE,QAAM,IAAI,MAAM;CACjB;AAGH,QAAO,AAAC,YAAoB,OAAO,mBAAmB;AACvD"}

package/dist/VitestTransactionIsolator-BKIrj3Uy.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"VitestTransactionIsolator-BKIrj3Uy.cjs","names":["api: TestAPI","createConnection: DatabaseConnection<TConn>","setup?: (trx: Transaction) => Promise<void>","level: IsolationLevel","use: (value: Transaction) => Promise<void>","testError: Error | undefined","wrappedTest: T","fixtures: FixtureCreators<Transaction, Extended>","fixtureDefinitions: Record<string, any>","use: (value: unknown) => Promise<void>"],"sources":["../src/VitestTransactionIsolator.ts"],"sourcesContent":["import type { TestAPI } from 'vitest';\n\n/**\n * Type definition for test fixtures that provide transaction access.\n * Used with Vitest's test.extend() API to inject transactions into tests.\n *\n * @template Transaction - The transaction type specific to the database driver\n * @template Extended - Additional context properties provided by the extend function\n */\nexport interface DatabaseFixtures<Transaction, Extended = object> {\n  /**\n   * The database transaction available to the test.\n   * All database operations should use this transaction to ensure proper rollback.\n   */\n  trx: Transaction;\n}\n\n/**\n * Combined fixtures type that merges the base transaction fixture with extended context.\n */\nexport type ExtendedDatabaseFixtures<\n  Transaction,\n  Extended = object,\n> = DatabaseFixtures<Transaction> & Extended;\n\n/**\n * Function type for extending test context with additional properties.\n * Receives the transaction and returns additional context to be merged with { trx }.\n *\n * @template Transaction - The transaction type\n * @template Extended - The type of additional context to provide\n *\n * @example\n * ```typescript\n * const extendContext: ExtendContextFn<Transaction<DB>, { factory: KyselyFactory }> =\n *   (trx) => ({ factory: new KyselyFactory(builders, seeds, trx) });\n * ```\n */\nexport type ExtendContextFn<Transaction, Extended> = (\n  trx: Transaction,\n) => Extended | Promise<Extended>;\n\n/**\n * PostgreSQL transaction isolation levels.\n * Controls the visibility of concurrent transactions.\n *\n * @see https://www.postgresql.org/docs/current/transaction-iso.html\n */\nexport enum IsolationLevel {\n  /**\n   * Lowest isolation level. Allows dirty reads.\n   * Not recommended for testing.\n   */\n  READ_UNCOMMITTED = 'READ UNCOMMITTED',\n  /**\n   * Default PostgreSQL isolation level.\n   * Prevents dirty reads but allows non-repeatable reads.\n   */\n  READ_COMMITTED = 'READ COMMITTED',\n  /**\n   * Prevents dirty reads and non-repeatable reads.\n   * Recommended for most test scenarios.\n   */\n  REPEATABLE_READ = 'REPEATABLE READ',\n  /**\n   * Highest isolation level. Prevents all phenomena.\n   * May cause performance overhead in tests.\n   */\n  SERIALIZABLE = 'SERIALIZABLE',\n}\n\n/**\n * Abstract base class for implementing database transaction isolation in Vitest tests.\n * Provides automatic transaction rollback after each test to maintain test isolation.\n * Subclasses must implement the transact() method for their specific database driver.\n *\n * @template TConn - The database connection type\n * @template Transaction - The transaction type\n *\n * @example\n * ```typescript\n * // Implement for your database driver\n * class MyDatabaseIsolator extends VitestPostgresTransactionIsolator<MyDB, MyTx> {\n *   async transact(conn: MyDB, level: IsolationLevel, fn: (tx: MyTx) => Promise<void>) {\n *     await conn.transaction(level, fn);\n *   }\n * }\n *\n * // Use in tests\n * const isolator = new MyDatabaseIsolator(test);\n * const isolatedTest = isolator.wrapVitestWithTransaction(db);\n *\n * isolatedTest('should create user', async ({ trx }) => {\n *   await trx.insert('users', { name: 'Test' });\n *   // Data is automatically rolled back after test\n * });\n * ```\n */\nexport abstract class VitestPostgresTransactionIsolator<TConn, Transaction> {\n  /**\n   * Abstract method to create a transaction with the specified isolation level.\n   * Must be implemented by subclasses for specific database drivers.\n   *\n   * @param conn - The database connection\n   * @param isolationLevel - The transaction isolation level\n   * @param fn - The function to execute within the transaction\n   * @returns Promise that resolves when the transaction completes\n   */\n  abstract transact(\n    conn: TConn,\n    isolationLevel: IsolationLevel,\n    fn: (trx: Transaction) => Promise<void>,\n  ): Promise<void>;\n\n  abstract destroy(conn: TConn): Promise<void>;\n  /**\n   * Creates a new VitestPostgresTransactionIsolator instance.\n   *\n   * @param api - The Vitest test API (usually the `test` export from vitest)\n   */\n  constructor(private readonly api: TestAPI) {}\n\n  /**\n   * Creates a wrapped version of Vitest's test API that provides transaction isolation.\n   * Each test will run within a database transaction that is automatically rolled back.\n   *\n   * @param conn - The database connection to use\n   * @param setup - Optional setup function to run within the transaction before each test\n   * @param level - The transaction isolation level (defaults to REPEATABLE_READ)\n   * @returns A wrapped test API with transaction support\n   *\n   * @example\n   * ```typescript\n   * const isolatedTest = isolator.wrapVitestWithTransaction(db, async (trx) => {\n   *   // Optional setup: create common test data\n   *   await trx.insert('settings', { key: 'test', value: 'true' });\n   * });\n   *\n   * isolatedTest('test with transaction', async ({ trx }) => {\n   *   const user = await trx.insert('users', { name: 'Test' });\n   *   expect(user).toBeDefined();\n   * });\n   * ```\n   */\n  wrapVitestWithTransaction(\n    createConnection: DatabaseConnection<TConn>,\n    setup?: (trx: Transaction) => Promise<void>,\n    level: IsolationLevel = IsolationLevel.REPEATABLE_READ,\n  ) {\n    return this.api.extend<DatabaseFixtures<Transaction>>({\n      // This fixture automatically provides a transaction to each test\n      trx: async ({}, use: (value: Transaction) => Promise<void>) => {\n        // Create a custom error class for rollback\n        class TestRollback extends Error {\n          constructor() {\n            super('Test rollback');\n            this.name = 'TestRollback';\n          }\n        }\n\n        let testError: Error | undefined;\n        const conn = await createConnection();\n        try {\n          await this.transact(conn, level, async (transaction) => {\n            try {\n              // Provide the transaction to the test\n              await setup?.(transaction);\n              await use(transaction);\n            } catch (error) {\n              // Capture any test errors\n              testError = error as Error;\n            }\n\n            // Always throw to trigger rollback\n            throw new TestRollback();\n          });\n        } catch (error) {\n          // Only rethrow if it's not our rollback error\n          if (!(error instanceof TestRollback)) {\n            throw error;\n          }\n\n          // If the test had an error, throw it now\n          if (testError) {\n            throw testError;\n          }\n        } finally {\n          await this.destroy(conn);\n        }\n      },\n    });\n  }\n}\n\nexport type DatabaseConnectionFn<Conn> = () => Conn | Promise<Conn>;\nexport type DatabaseConnection<Conn> = DatabaseConnectionFn<Conn>;\n\n/**\n * Type for fixture creator functions that depend on the transaction.\n * Each function receives the transaction and returns the fixture value.\n */\nexport type FixtureCreators<\n  Transaction,\n  Extended extends Record<string, unknown>,\n> = {\n  [K in keyof Extended]: (\n    trx: Transaction,\n  ) => Extended[K] | Promise<Extended[K]>;\n};\n\n/**\n * Extends a wrapped test API with additional fixtures that depend on the transaction.\n * This allows composing test context with factories, repositories, or other helpers.\n *\n * @template Transaction - The transaction type\n * @template Extended - The type of additional context to provide\n * @param wrappedTest - The base wrapped test from wrapVitestWithTransaction\n * @param fixtures - Object mapping fixture names to creator functions\n * @returns An extended test API with both trx and the additional fixtures\n *\n * @example\n * ```typescript\n * import { wrapVitestKyselyTransaction, extendWithFixtures } from '@geekmidas/testkit/kysely';\n *\n * // Create base wrapped test\n * const baseTest = wrapVitestKyselyTransaction(test, db, createTestTables);\n *\n * // Extend with fixtures\n * const it = extendWithFixtures(baseTest, {\n *   factory: (trx) => new KyselyFactory(builders, seeds, trx),\n *   userRepo: (trx) => new UserRepository(trx),\n * });\n *\n * // Use in tests - trx and all fixtures are available\n * it('should create user with factory', async ({ trx, factory, userRepo }) => {\n *   const user = await factory.insert('user', { name: 'Test' });\n *   expect(user).toBeDefined();\n * });\n * ```\n */\nexport function extendWithFixtures<\n  Transaction,\n  Extended extends Record<string, unknown>,\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  T extends ReturnType<TestAPI['extend']> = any,\n>(\n  wrappedTest: T,\n  fixtures: FixtureCreators<Transaction, Extended>,\n): T & {\n  <C extends object>(\n    name: string,\n    fn: (\n      context: DatabaseFixtures<Transaction> & Extended & C,\n    ) => Promise<void>,\n  ): void;\n  <C extends object>(\n    name: string,\n    options: object,\n    fn: (\n      context: DatabaseFixtures<Transaction> & Extended & C,\n    ) => Promise<void>,\n  ): void;\n} {\n  // Build fixture definitions for Vitest's extend API\n  const fixtureDefinitions: Record<string, any> = {};\n\n  for (const [key, creator] of Object.entries(fixtures)) {\n    fixtureDefinitions[key] = async (\n      { trx }: { trx: Transaction },\n      use: (value: unknown) => Promise<void>,\n    ) => {\n      const value = await (creator as (trx: Transaction) => unknown)(trx);\n      await use(value);\n    };\n  }\n\n  return (wrappedTest as any).extend(fixtureDefinitions);\n}\n"],"mappings":";;;;;;;;AAgDA,IAAY,4DAAL;;;;;AAKL;;;;;AAKA;;;;;AAKA;;;;;AAKA;;AACD;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6BD,IAAsB,oCAAtB,MAA4E;;;;;;CAsB1E,YAA6BA,KAAc;EAAd;CAAgB;;;;;;;;;;;;;;;;;;;;;;;CAwB7C,0BACEC,kBACAC,OACAC,QAAwB,eAAe,iBACvC;AACA,SAAO,KAAK,IAAI,OAAsC,EAEpD,KAAK,OAAO,EAAE,EAAEC,QAA+C;GAE7D,MAAM,qBAAqB,MAAM;IAC/B,cAAc;AACZ,WAAM,gBAAgB;AACtB,UAAK,OAAO;IACb;GACF;GAED,IAAIC;GACJ,MAAM,OAAO,MAAM,kBAAkB;AACrC,OAAI;AACF,UAAM,KAAK,SAAS,MAAM,OAAO,OAAO,gBAAgB;AACtD,SAAI;AAEF,YAAM,QAAQ,YAAY;AAC1B,YAAM,IAAI,YAAY;KACvB,SAAQ,OAAO;AAEd,kBAAY;KACb;AAGD,WAAM,IAAI;IACX,EAAC;GACH,SAAQ,OAAO;AAEd,UAAM,iBAAiB,cACrB,OAAM;AAIR,QAAI,UACF,OAAM;GAET,UAAS;AACR,UAAM,KAAK,QAAQ,KAAK;GACzB;EACF,EACF,EAAC;CACH;AACF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgDD,SAAgB,mBAMdC,aACAC,UAeA;CAEA,MAAMC,qBAA0C,CAAE;AAElD,MAAK,MAAM,CAAC,KAAK,QAAQ,IAAI,OAAO,QAAQ,SAAS,CACnD,oBAAmB,OAAO,OACxB,EAAE,KAA2B,EAC7BC,QACG;EACH,MAAM,QAAQ,MAAM,AAAC,QAA0C,IAAI;AACnE,QAAM,IAAI,MAAM;CACjB;AAGH,QAAO,AAAC,YAAoB,OAAO,mBAAmB;AACvD"}