@geekmidas/testkit 0.1.0 → 0.2.0

package/README.md

@@ -33,8 +33,21 @@ yarn add -D @geekmidas/testkit
 ## Subpath Exports
 
 ```typescript
-import { KyselyFactory } from '@geekmidas/testkit/kysely';
-import { ObjectionFactory } from '@geekmidas/testkit/objection';
+// Kysely utilities
+import {
+  KyselyFactory,
+  wrapVitestKyselyTransaction,
+  extendWithFixtures,
+} from '@geekmidas/testkit/kysely';
+
+// Objection.js utilities
+import {
+  ObjectionFactory,
+  wrapVitestObjectionTransaction,
+  extendWithFixtures,
+} from '@geekmidas/testkit/objection';
+
+// Other utilities
 import { faker } from '@geekmidas/testkit/faker';
 import { waitFor } from '@geekmidas/testkit/timer';
 import { itWithDir } from '@geekmidas/testkit/os';
@@ -71,7 +84,7 @@ interface Database {
 const builders = {
   user: KyselyFactory.createBuilder<Database, 'users'>(
     'users',
-    (attrs, factory, db, faker) => ({
+    ({ attrs, faker }) => ({
       id: faker.string.uuid(),
       name: faker.person.fullName(),
       email: faker.internet.email(),
@@ -81,7 +94,7 @@ const builders = {
   ),
   post: KyselyFactory.createBuilder<Database, 'posts'>(
     'posts',
-    (attrs, factory, db, faker) => ({
+    ({ attrs, faker }) => ({
       id: faker.string.uuid(),
       title: 'Test Post',
       content: faker.lorem.paragraph(),
@@ -127,7 +140,7 @@ class User extends Model {
 const builders = {
   user: ObjectionFactory.createBuilder(
     User,
-    (attrs, factory, db, faker) => ({
+    ({ attrs, faker }) => ({
       id: faker.string.uuid(),
       name: faker.person.fullName(),
       email: faker.internet.email(),
@@ -337,9 +350,145 @@ afterAll(async () => {
 });
 ```
 
-## Transaction Isolation
+## Vitest Transaction Isolation
+
+TestKit provides Vitest-specific helpers for automatic transaction isolation. Each test runs in a transaction that is automatically rolled back after the test completes.
+
+### Basic Usage
+
+```typescript
+import { test } from 'vitest';
+import { wrapVitestKyselyTransaction } from '@geekmidas/testkit/kysely';
+import { db } from './database';
+
+// Wrap Vitest's test function with transaction support
+const it = wrapVitestKyselyTransaction<Database>(
+  test,
+  () => db,
+  async (trx) => {
+    // Optional: Set up test tables or seed data
+    await trx.schema.createTable('users').execute();
+  }
+);
+
+// Each test gets its own transaction
+it('should create user', async ({ trx }) => {
+  const user = await trx
+    .insertInto('users')
+    .values({ name: 'John' })
+    .returningAll()
+    .executeTakeFirst();
+
+  expect(user.name).toBe('John');
+  // Transaction is automatically rolled back after test
+});
+```
+
+### Extending with Fixtures
+
+Use `extendWithFixtures` to add factory and other fixtures to your tests:
+
+```typescript
+import { test } from 'vitest';
+import {
+  wrapVitestKyselyTransaction,
+  extendWithFixtures,
+  KyselyFactory,
+} from '@geekmidas/testkit/kysely';
+
+// Define builders
+const builders = {
+  user: KyselyFactory.createBuilder<Database, 'users'>('users', ({ faker }) => ({
+    name: faker.person.fullName(),
+    email: faker.internet.email(),
+  })),
+  post: KyselyFactory.createBuilder<Database, 'posts'>('posts', ({ faker }) => ({
+    title: faker.lorem.sentence(),
+    content: faker.lorem.paragraphs(),
+  })),
+};
+
+// Create base test with transaction
+const baseTest = wrapVitestKyselyTransaction<Database>(test, () => db);
+
+// Extend with factory fixture
+const it = extendWithFixtures<
+  Database,
+  { factory: KyselyFactory<Database, typeof builders, {}> }
+>(baseTest, {
+  factory: (trx) => new KyselyFactory(builders, {}, trx),
+});
+
+// Both trx and factory are available in tests
+it('should create user with factory', async ({ trx, factory }) => {
+  const user = await factory.insert('user', { name: 'Jane' });
+
+  expect(user.id).toBeDefined();
+  expect(user.name).toBe('Jane');
+
+  // Verify in database
+  const found = await trx
+    .selectFrom('users')
+    .where('id', '=', user.id)
+    .selectAll()
+    .executeTakeFirst();
+
+  expect(found?.name).toBe('Jane');
+});
+
+it('should create related records', async ({ factory }) => {
+  const user = await factory.insert('user');
+  const posts = await factory.insertMany(3, 'post', { userId: user.id });
+
+  expect(posts).toHaveLength(3);
+  expect(posts[0].userId).toBe(user.id);
+});
+```
+
+### Multiple Fixtures
+
+You can add multiple fixtures that all receive the transaction:
+
+```typescript
+const it = extendWithFixtures<
+  Database,
+  {
+    factory: KyselyFactory<Database, typeof builders, {}>;
+    userRepo: UserRepository;
+    config: { maxUsers: number };
+  }
+>(baseTest, {
+  factory: (trx) => new KyselyFactory(builders, {}, trx),
+  userRepo: (trx) => new UserRepository(trx),
+  config: () => ({ maxUsers: 100 }), // Fixtures can ignore trx if not needed
+});
+
+it('should use multiple fixtures', async ({ factory, userRepo, config }) => {
+  const user = await factory.insert('user');
+  const found = await userRepo.findById(user.id);
+  expect(found).toBeDefined();
+  expect(config.maxUsers).toBe(100);
+});
+```
+
+### With Objection.js
+
+```typescript
+import { wrapVitestObjectionTransaction, extendWithFixtures } from '@geekmidas/testkit/objection';
+
+const baseTest = wrapVitestObjectionTransaction(test, () => knex);
+
+const it = extendWithFixtures<{ factory: ObjectionFactory<typeof builders, {}> }>(
+  baseTest,
+  {
+    factory: (trx) => new ObjectionFactory(builders, {}, trx),
+  }
+);
+```
+
+## Manual Transaction Isolation
 
-TestKit supports transaction-based test isolation:
+For more control, you can manage transactions manually:
 
 ```typescript
 describe('User Service', () => {
@@ -402,12 +551,12 @@ class KyselyFactory<DB, Builders, Seeds> {
 
   static createBuilder<DB, TableName extends keyof DB & string>(
     table: TableName,
-    item?: (
-      attrs: Partial<Insertable<DB[TableName]>>,
-      factory: KyselyFactory,
-      db: Kysely<DB>,
-      faker: FakerFactory
-    ) => Partial<Insertable<DB[TableName]>> | Promise<...>,
+    defaults?: (context: {
+      attrs: Partial<Insertable<DB[TableName]>>;
+      factory: KyselyFactory;
+      db: Kysely<DB>;
+      faker: FakerFactory;
+    }) => Partial<Insertable<DB[TableName]>> | Promise<...>,
     autoInsert?: boolean
   ): BuilderFunction;
 

package/dist/{Factory-BZ8uMoXl.d.cts → Factory-D7oHtI2D.d.cts}

@@ -1,4 +1,4 @@
-import { FakerFactory } from "./faker-Cg76aFNO.cjs";
+import { FakerFactory } from "./faker-Dg3trU4a.cjs";
 
 //#region src/Factory.d.ts
 
@@ -129,4 +129,4 @@ type MixedFactoryBuilder<Attrs = any, Factory = any, Result = any, DB = any> = (
 type FactorySeed<Attrs = any, Factory = any, Result = any, DB = any> = (attrs: Attrs, factory: Factory, db: DB) => Promise<Result>;
 //#endregion
 export { Factory, FactorySeed, MixedFactoryBuilder };
-//# sourceMappingURL=Factory-BZ8uMoXl.d.cts.map
+//# sourceMappingURL=Factory-D7oHtI2D.d.cts.map

package/dist/Factory.d.cts

@@ -1,3 +1,3 @@
-import "./faker-Cg76aFNO.cjs";
-import { Factory, FactorySeed, MixedFactoryBuilder } from "./Factory-BZ8uMoXl.cjs";
+import "./faker-Dg3trU4a.cjs";
+import { Factory, FactorySeed, MixedFactoryBuilder } from "./Factory-D7oHtI2D.cjs";
 export { Factory, FactorySeed, MixedFactoryBuilder };

package/dist/{KyselyFactory-BFygzOlO.d.cts → KyselyFactory-dYdviox2.d.cts}

@@ -1,5 +1,5 @@
-import { FakerFactory } from "./faker-Cg76aFNO.cjs";
-import { Factory, FactorySeed } from "./Factory-BZ8uMoXl.cjs";
+import { FakerFactory } from "./faker-Dg3trU4a.cjs";
+import { Factory, FactorySeed } from "./Factory-D7oHtI2D.cjs";
 import { ControlledTransaction, Insertable, Kysely, Selectable } from "kysely";
 
 //#region src/KyselyFactory.d.ts
@@ -211,4 +211,4 @@ declare class KyselyFactory<DB, Builders extends Record<string, any>, Seeds exte
 }
 //#endregion
 export { KyselyFactory };
-//# sourceMappingURL=KyselyFactory-BFygzOlO.d.cts.map
+//# sourceMappingURL=KyselyFactory-dYdviox2.d.cts.map

package/dist/KyselyFactory.d.cts

@@ -1,4 +1,4 @@
-import "./faker-Cg76aFNO.cjs";
-import "./Factory-BZ8uMoXl.cjs";
-import { KyselyFactory } from "./KyselyFactory-BFygzOlO.cjs";
+import "./faker-Dg3trU4a.cjs";
+import "./Factory-D7oHtI2D.cjs";
+import { KyselyFactory } from "./KyselyFactory-dYdviox2.cjs";
 export { KyselyFactory };

package/dist/{ObjectionFactory-CeSIN3kZ.d.cts → ObjectionFactory-0gUdx8bB.d.cts}

@@ -1,5 +1,5 @@
-import { FakerFactory } from "./faker-Cg76aFNO.cjs";
-import { Factory, FactorySeed } from "./Factory-BZ8uMoXl.cjs";
+import { FakerFactory } from "./faker-Dg3trU4a.cjs";
+import { Factory, FactorySeed } from "./Factory-D7oHtI2D.cjs";
 import { Knex } from "knex";
 import { Model } from "objection";
 
@@ -224,4 +224,4 @@ declare class ObjectionFactory<Builders extends Record<string, any>, Seeds exten
 }
 //#endregion
 export { ObjectionFactory };
-//# sourceMappingURL=ObjectionFactory-CeSIN3kZ.d.cts.map
+//# sourceMappingURL=ObjectionFactory-0gUdx8bB.d.cts.map

package/dist/ObjectionFactory.d.cts

@@ -1,4 +1,4 @@
-import "./faker-Cg76aFNO.cjs";
-import "./Factory-BZ8uMoXl.cjs";
-import { ObjectionFactory } from "./ObjectionFactory-CeSIN3kZ.cjs";
+import "./faker-Dg3trU4a.cjs";
+import "./Factory-D7oHtI2D.cjs";
+import { ObjectionFactory } from "./ObjectionFactory-0gUdx8bB.cjs";
 export { ObjectionFactory };

package/dist/{VitestKyselyTransactionIsolator-XDL3ngs_.mjs → VitestKyselyTransactionIsolator-CNURW8y6.mjs}

@@ -1,4 +1,4 @@
-import { VitestPostgresTransactionIsolator } from "./VitestTransactionIsolator-BIaMs4c2.mjs";
+import { VitestPostgresTransactionIsolator } from "./VitestTransactionIsolator-DQ7tLqgV.mjs";
 
 //#region src/VitestKyselyTransactionIsolator.ts
 /**
@@ -57,4 +57,4 @@ var VitestKyselyTransactionIsolator = class extends VitestPostgresTransactionIso
 
 //#endregion
 export { VitestKyselyTransactionIsolator };
-//# sourceMappingURL=VitestKyselyTransactionIsolator-XDL3ngs_.mjs.map
+//# sourceMappingURL=VitestKyselyTransactionIsolator-CNURW8y6.mjs.map

package/dist/{VitestKyselyTransactionIsolator-XDL3ngs_.mjs.map → VitestKyselyTransactionIsolator-CNURW8y6.mjs.map}

@@ -1 +1 @@
-{"version":3,"file":"VitestKyselyTransactionIsolator-XDL3ngs_.mjs","names":["conn: Kysely<Database>","level: IsolationLevel","fn: (trx: Transaction<Database>) => Promise<void>"],"sources":["../src/VitestKyselyTransactionIsolator.ts"],"sourcesContent":["import type { Kysely, Transaction } from 'kysely';\nimport {\n  type IsolationLevel,\n  VitestPostgresTransactionIsolator,\n} from './VitestTransactionIsolator';\n\n/**\n * Kysely-specific implementation of the Vitest transaction isolator.\n * Provides automatic transaction rollback for test isolation using Kysely's transaction API.\n * Each test runs within a database transaction that is rolled back after completion,\n * ensuring a clean state between tests without the overhead of recreating data.\n *\n * @template Database - The database schema type\n *\n * @example\n * ```typescript\n * import { VitestKyselyTransactionIsolator } from '@geekmidas/testkit';\n * import { db } from './database';\n *\n * // Create isolator instance\n * const isolator = new VitestKyselyTransactionIsolator<Database>();\n *\n * // In your test setup\n * beforeEach(async () => {\n *   await isolator.start(db);\n * });\n *\n * afterEach(async () => {\n *   await isolator.rollback();\n * });\n *\n * // Tests run in isolated transactions\n * it('should create user', async () => {\n *   const user = await db.insertInto('users')\n *     .values({ name: 'Test User' })\n *     .returningAll()\n *     .executeTakeFirst();\n *\n *   expect(user).toBeDefined();\n *   // This data will be rolled back after the test\n * });\n * ```\n */\nexport class VitestKyselyTransactionIsolator<\n  Database,\n> extends VitestPostgresTransactionIsolator<\n  Kysely<Database>,\n  Transaction<Database>\n> {\n  async destroy(conn: Kysely<Database>): Promise<void> {\n    // return conn.destroy();\n  }\n  /**\n   * Creates a Kysely transaction with the specified isolation level.\n   * Implements the abstract transact method from VitestPostgresTransactionIsolator.\n   *\n   * @param conn - The Kysely database connection\n   * @param level - 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  async transact(\n    conn: Kysely<Database>,\n    level: IsolationLevel,\n    fn: (trx: Transaction<Database>) => Promise<void>,\n  ): Promise<void> {\n    const isolationLevel =\n      level.toLocaleLowerCase() as Lowercase<IsolationLevel>;\n    await conn.transaction().setIsolationLevel(isolationLevel).execute(fn);\n  }\n  // Implement any Kysely-specific transaction logic here\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA2CA,IAAa,kCAAb,cAEU,kCAGR;CACA,MAAM,QAAQA,MAAuC,CAEpD;;;;;;;;;;CAUD,MAAM,SACJA,MACAC,OACAC,IACe;EACf,MAAM,iBACJ,MAAM,mBAAmB;AAC3B,QAAM,KAAK,aAAa,CAAC,kBAAkB,eAAe,CAAC,QAAQ,GAAG;CACvE;AAEF"}
+{"version":3,"file":"VitestKyselyTransactionIsolator-CNURW8y6.mjs","names":["conn: Kysely<Database>","level: IsolationLevel","fn: (trx: Transaction<Database>) => Promise<void>"],"sources":["../src/VitestKyselyTransactionIsolator.ts"],"sourcesContent":["import type { Kysely, Transaction } from 'kysely';\nimport {\n  type IsolationLevel,\n  VitestPostgresTransactionIsolator,\n} from './VitestTransactionIsolator';\n\n/**\n * Kysely-specific implementation of the Vitest transaction isolator.\n * Provides automatic transaction rollback for test isolation using Kysely's transaction API.\n * Each test runs within a database transaction that is rolled back after completion,\n * ensuring a clean state between tests without the overhead of recreating data.\n *\n * @template Database - The database schema type\n *\n * @example\n * ```typescript\n * import { VitestKyselyTransactionIsolator } from '@geekmidas/testkit';\n * import { db } from './database';\n *\n * // Create isolator instance\n * const isolator = new VitestKyselyTransactionIsolator<Database>();\n *\n * // In your test setup\n * beforeEach(async () => {\n *   await isolator.start(db);\n * });\n *\n * afterEach(async () => {\n *   await isolator.rollback();\n * });\n *\n * // Tests run in isolated transactions\n * it('should create user', async () => {\n *   const user = await db.insertInto('users')\n *     .values({ name: 'Test User' })\n *     .returningAll()\n *     .executeTakeFirst();\n *\n *   expect(user).toBeDefined();\n *   // This data will be rolled back after the test\n * });\n * ```\n */\nexport class VitestKyselyTransactionIsolator<\n  Database,\n> extends VitestPostgresTransactionIsolator<\n  Kysely<Database>,\n  Transaction<Database>\n> {\n  async destroy(conn: Kysely<Database>): Promise<void> {\n    // return conn.destroy();\n  }\n  /**\n   * Creates a Kysely transaction with the specified isolation level.\n   * Implements the abstract transact method from VitestPostgresTransactionIsolator.\n   *\n   * @param conn - The Kysely database connection\n   * @param level - 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  async transact(\n    conn: Kysely<Database>,\n    level: IsolationLevel,\n    fn: (trx: Transaction<Database>) => Promise<void>,\n  ): Promise<void> {\n    const isolationLevel =\n      level.toLocaleLowerCase() as Lowercase<IsolationLevel>;\n    await conn.transaction().setIsolationLevel(isolationLevel).execute(fn);\n  }\n  // Implement any Kysely-specific transaction logic here\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA2CA,IAAa,kCAAb,cAEU,kCAGR;CACA,MAAM,QAAQA,MAAuC,CAEpD;;;;;;;;;;CAUD,MAAM,SACJA,MACAC,OACAC,IACe;EACf,MAAM,iBACJ,MAAM,mBAAmB;AAC3B,QAAM,KAAK,aAAa,CAAC,kBAAkB,eAAe,CAAC,QAAQ,GAAG;CACvE;AAEF"}

package/dist/{VitestKyselyTransactionIsolator-DnyZMaA-.d.mts → VitestKyselyTransactionIsolator-D3EZZhjZ.d.cts}

@@ -1,4 +1,4 @@
-import { IsolationLevel, VitestPostgresTransactionIsolator } from "./VitestTransactionIsolator-DWDbnITQ.mjs";
+import { IsolationLevel, VitestPostgresTransactionIsolator } from "./VitestTransactionIsolator-CwQaxZLP.cjs";
 import { Kysely, Transaction } from "kysely";
 
 //#region src/VitestKyselyTransactionIsolator.d.ts
@@ -55,4 +55,4 @@ declare class VitestKyselyTransactionIsolator<Database> extends VitestPostgresTr
 }
 //#endregion
 export { VitestKyselyTransactionIsolator };
-//# sourceMappingURL=VitestKyselyTransactionIsolator-DnyZMaA-.d.mts.map
+//# sourceMappingURL=VitestKyselyTransactionIsolator-D3EZZhjZ.d.cts.map

package/dist/{VitestKyselyTransactionIsolator-4HOeLQ0d.d.cts → VitestKyselyTransactionIsolator-Dxlp1u0f.d.mts}

@@ -1,4 +1,4 @@
-import { IsolationLevel, VitestPostgresTransactionIsolator } from "./VitestTransactionIsolator-CyG_i_Nj.cjs";
+import { IsolationLevel, VitestPostgresTransactionIsolator } from "./VitestTransactionIsolator-BvR19bYn.mjs";
 import { Kysely, Transaction } from "kysely";
 
 //#region src/VitestKyselyTransactionIsolator.d.ts
@@ -55,4 +55,4 @@ declare class VitestKyselyTransactionIsolator<Database> extends VitestPostgresTr
 }
 //#endregion
 export { VitestKyselyTransactionIsolator };
-//# sourceMappingURL=VitestKyselyTransactionIsolator-4HOeLQ0d.d.cts.map
+//# sourceMappingURL=VitestKyselyTransactionIsolator-Dxlp1u0f.d.mts.map

package/dist/{VitestKyselyTransactionIsolator-DX_VPKS-.cjs → VitestKyselyTransactionIsolator-EvDLk5zg.cjs}

@@ -1,4 +1,4 @@
-const require_VitestTransactionIsolator = require('./VitestTransactionIsolator-BKIrj3Uy.cjs');
+const require_VitestTransactionIsolator = require('./VitestTransactionIsolator-CMfJXZP8.cjs');
 
 //#region src/VitestKyselyTransactionIsolator.ts
 /**
@@ -62,4 +62,4 @@ Object.defineProperty(exports, 'VitestKyselyTransactionIsolator', {
     return VitestKyselyTransactionIsolator;
   }
 });
-//# sourceMappingURL=VitestKyselyTransactionIsolator-DX_VPKS-.cjs.map
+//# sourceMappingURL=VitestKyselyTransactionIsolator-EvDLk5zg.cjs.map

package/dist/{VitestKyselyTransactionIsolator-DX_VPKS-.cjs.map → VitestKyselyTransactionIsolator-EvDLk5zg.cjs.map}

@@ -1 +1 @@
-{"version":3,"file":"VitestKyselyTransactionIsolator-DX_VPKS-.cjs","names":["VitestPostgresTransactionIsolator","conn: Kysely<Database>","level: IsolationLevel","fn: (trx: Transaction<Database>) => Promise<void>"],"sources":["../src/VitestKyselyTransactionIsolator.ts"],"sourcesContent":["import type { Kysely, Transaction } from 'kysely';\nimport {\n  type IsolationLevel,\n  VitestPostgresTransactionIsolator,\n} from './VitestTransactionIsolator';\n\n/**\n * Kysely-specific implementation of the Vitest transaction isolator.\n * Provides automatic transaction rollback for test isolation using Kysely's transaction API.\n * Each test runs within a database transaction that is rolled back after completion,\n * ensuring a clean state between tests without the overhead of recreating data.\n *\n * @template Database - The database schema type\n *\n * @example\n * ```typescript\n * import { VitestKyselyTransactionIsolator } from '@geekmidas/testkit';\n * import { db } from './database';\n *\n * // Create isolator instance\n * const isolator = new VitestKyselyTransactionIsolator<Database>();\n *\n * // In your test setup\n * beforeEach(async () => {\n *   await isolator.start(db);\n * });\n *\n * afterEach(async () => {\n *   await isolator.rollback();\n * });\n *\n * // Tests run in isolated transactions\n * it('should create user', async () => {\n *   const user = await db.insertInto('users')\n *     .values({ name: 'Test User' })\n *     .returningAll()\n *     .executeTakeFirst();\n *\n *   expect(user).toBeDefined();\n *   // This data will be rolled back after the test\n * });\n * ```\n */\nexport class VitestKyselyTransactionIsolator<\n  Database,\n> extends VitestPostgresTransactionIsolator<\n  Kysely<Database>,\n  Transaction<Database>\n> {\n  async destroy(conn: Kysely<Database>): Promise<void> {\n    // return conn.destroy();\n  }\n  /**\n   * Creates a Kysely transaction with the specified isolation level.\n   * Implements the abstract transact method from VitestPostgresTransactionIsolator.\n   *\n   * @param conn - The Kysely database connection\n   * @param level - 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  async transact(\n    conn: Kysely<Database>,\n    level: IsolationLevel,\n    fn: (trx: Transaction<Database>) => Promise<void>,\n  ): Promise<void> {\n    const isolationLevel =\n      level.toLocaleLowerCase() as Lowercase<IsolationLevel>;\n    await conn.transaction().setIsolationLevel(isolationLevel).execute(fn);\n  }\n  // Implement any Kysely-specific transaction logic here\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA2CA,IAAa,kCAAb,cAEUA,oEAGR;CACA,MAAM,QAAQC,MAAuC,CAEpD;;;;;;;;;;CAUD,MAAM,SACJA,MACAC,OACAC,IACe;EACf,MAAM,iBACJ,MAAM,mBAAmB;AAC3B,QAAM,KAAK,aAAa,CAAC,kBAAkB,eAAe,CAAC,QAAQ,GAAG;CACvE;AAEF"}
+{"version":3,"file":"VitestKyselyTransactionIsolator-EvDLk5zg.cjs","names":["VitestPostgresTransactionIsolator","conn: Kysely<Database>","level: IsolationLevel","fn: (trx: Transaction<Database>) => Promise<void>"],"sources":["../src/VitestKyselyTransactionIsolator.ts"],"sourcesContent":["import type { Kysely, Transaction } from 'kysely';\nimport {\n  type IsolationLevel,\n  VitestPostgresTransactionIsolator,\n} from './VitestTransactionIsolator';\n\n/**\n * Kysely-specific implementation of the Vitest transaction isolator.\n * Provides automatic transaction rollback for test isolation using Kysely's transaction API.\n * Each test runs within a database transaction that is rolled back after completion,\n * ensuring a clean state between tests without the overhead of recreating data.\n *\n * @template Database - The database schema type\n *\n * @example\n * ```typescript\n * import { VitestKyselyTransactionIsolator } from '@geekmidas/testkit';\n * import { db } from './database';\n *\n * // Create isolator instance\n * const isolator = new VitestKyselyTransactionIsolator<Database>();\n *\n * // In your test setup\n * beforeEach(async () => {\n *   await isolator.start(db);\n * });\n *\n * afterEach(async () => {\n *   await isolator.rollback();\n * });\n *\n * // Tests run in isolated transactions\n * it('should create user', async () => {\n *   const user = await db.insertInto('users')\n *     .values({ name: 'Test User' })\n *     .returningAll()\n *     .executeTakeFirst();\n *\n *   expect(user).toBeDefined();\n *   // This data will be rolled back after the test\n * });\n * ```\n */\nexport class VitestKyselyTransactionIsolator<\n  Database,\n> extends VitestPostgresTransactionIsolator<\n  Kysely<Database>,\n  Transaction<Database>\n> {\n  async destroy(conn: Kysely<Database>): Promise<void> {\n    // return conn.destroy();\n  }\n  /**\n   * Creates a Kysely transaction with the specified isolation level.\n   * Implements the abstract transact method from VitestPostgresTransactionIsolator.\n   *\n   * @param conn - The Kysely database connection\n   * @param level - 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  async transact(\n    conn: Kysely<Database>,\n    level: IsolationLevel,\n    fn: (trx: Transaction<Database>) => Promise<void>,\n  ): Promise<void> {\n    const isolationLevel =\n      level.toLocaleLowerCase() as Lowercase<IsolationLevel>;\n    await conn.transaction().setIsolationLevel(isolationLevel).execute(fn);\n  }\n  // Implement any Kysely-specific transaction logic here\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA2CA,IAAa,kCAAb,cAEUA,oEAGR;CACA,MAAM,QAAQC,MAAuC,CAEpD;;;;;;;;;;CAUD,MAAM,SACJA,MACAC,OACAC,IACe;EACf,MAAM,iBACJ,MAAM,mBAAmB;AAC3B,QAAM,KAAK,aAAa,CAAC,kBAAkB,eAAe,CAAC,QAAQ,GAAG;CACvE;AAEF"}

package/dist/VitestKyselyTransactionIsolator.cjs

@@ -1,4 +1,4 @@
-require('./VitestTransactionIsolator-BKIrj3Uy.cjs');
-const require_VitestKyselyTransactionIsolator = require('./VitestKyselyTransactionIsolator-DX_VPKS-.cjs');
+require('./VitestTransactionIsolator-CMfJXZP8.cjs');
+const require_VitestKyselyTransactionIsolator = require('./VitestKyselyTransactionIsolator-EvDLk5zg.cjs');
 
 exports.VitestKyselyTransactionIsolator = require_VitestKyselyTransactionIsolator.VitestKyselyTransactionIsolator;

package/dist/VitestKyselyTransactionIsolator.d.cts

@@ -1,3 +1,3 @@
-import "./VitestTransactionIsolator-CyG_i_Nj.cjs";
-import { VitestKyselyTransactionIsolator } from "./VitestKyselyTransactionIsolator-4HOeLQ0d.cjs";
+import "./VitestTransactionIsolator-CwQaxZLP.cjs";
+import { VitestKyselyTransactionIsolator } from "./VitestKyselyTransactionIsolator-D3EZZhjZ.cjs";
 export { VitestKyselyTransactionIsolator };

package/dist/VitestKyselyTransactionIsolator.d.mts

@@ -1,3 +1,3 @@
-import "./VitestTransactionIsolator-DWDbnITQ.mjs";
-import { VitestKyselyTransactionIsolator } from "./VitestKyselyTransactionIsolator-DnyZMaA-.mjs";
+import "./VitestTransactionIsolator-BvR19bYn.mjs";
+import { VitestKyselyTransactionIsolator } from "./VitestKyselyTransactionIsolator-Dxlp1u0f.mjs";
 export { VitestKyselyTransactionIsolator };

package/dist/VitestKyselyTransactionIsolator.mjs

@@ -1,4 +1,4 @@
-import "./VitestTransactionIsolator-BIaMs4c2.mjs";
-import { VitestKyselyTransactionIsolator } from "./VitestKyselyTransactionIsolator-XDL3ngs_.mjs";
+import "./VitestTransactionIsolator-DQ7tLqgV.mjs";
+import { VitestKyselyTransactionIsolator } from "./VitestKyselyTransactionIsolator-CNURW8y6.mjs";
 
 export { VitestKyselyTransactionIsolator };

package/dist/{VitestObjectionTransactionIsolator-COVDlpEo.d.cts → VitestObjectionTransactionIsolator-1TpsPqfG.d.cts}

@@ -1,4 +1,4 @@
-import { IsolationLevel, VitestPostgresTransactionIsolator } from "./VitestTransactionIsolator-CyG_i_Nj.cjs";
+import { IsolationLevel, VitestPostgresTransactionIsolator } from "./VitestTransactionIsolator-CwQaxZLP.cjs";
 import { Knex } from "knex";
 
 //#region src/VitestObjectionTransactionIsolator.d.ts
@@ -56,4 +56,4 @@ declare class VitestObjectionTransactionIsolator extends VitestPostgresTransacti
 }
 //#endregion
 export { VitestObjectionTransactionIsolator };
-//# sourceMappingURL=VitestObjectionTransactionIsolator-COVDlpEo.d.cts.map
+//# sourceMappingURL=VitestObjectionTransactionIsolator-1TpsPqfG.d.cts.map

package/dist/{VitestObjectionTransactionIsolator-D_tlOtq8.cjs → VitestObjectionTransactionIsolator-CM5KTAFA.cjs}

@@ -1,4 +1,4 @@
-const require_VitestTransactionIsolator = require('./VitestTransactionIsolator-BKIrj3Uy.cjs');
+const require_VitestTransactionIsolator = require('./VitestTransactionIsolator-CMfJXZP8.cjs');
 
 //#region src/VitestObjectionTransactionIsolator.ts
 /**
@@ -65,4 +65,4 @@ Object.defineProperty(exports, 'VitestObjectionTransactionIsolator', {
     return VitestObjectionTransactionIsolator;
   }
 });
-//# sourceMappingURL=VitestObjectionTransactionIsolator-D_tlOtq8.cjs.map
+//# sourceMappingURL=VitestObjectionTransactionIsolator-CM5KTAFA.cjs.map

package/dist/{VitestObjectionTransactionIsolator-D_tlOtq8.cjs.map → VitestObjectionTransactionIsolator-CM5KTAFA.cjs.map}

@@ -1 +1 @@
-{"version":3,"file":"VitestObjectionTransactionIsolator-D_tlOtq8.cjs","names":["VitestPostgresTransactionIsolator","conn: Knex<any, any[]>","connection: Knex","level: IsolationLevel","fn: (trx: Knex.Transaction) => Promise<void>"],"sources":["../src/VitestObjectionTransactionIsolator.ts"],"sourcesContent":["import type { Knex } from 'knex';\nimport {\n  type IsolationLevel,\n  VitestPostgresTransactionIsolator,\n} from './VitestTransactionIsolator';\n\n/**\n * Objection.js-specific implementation of the Vitest transaction isolator.\n * Provides automatic transaction rollback for test isolation using Objection.js and Knex transaction API.\n * Each test runs within a database transaction that is rolled back after completion,\n * ensuring a clean state between tests without the overhead of recreating data.\n *\n * @example\n * ```typescript\n * import { VitestObjectionTransactionIsolator } from '@geekmidas/testkit';\n * import { knex } from './database';\n * import { User } from './models';\n * import { test } from 'vitest';\n *\n * // Create isolator instance\n * const isolator = new VitestObjectionTransactionIsolator(test);\n *\n * // Use with wrapped test API\n * const isolatedTest = isolator.wrapVitestWithTransaction(knex);\n *\n * isolatedTest('should create user', async ({ trx }) => {\n *   const user = await User.query(trx)\n *     .insert({ name: 'Test User' });\n *\n *   expect(user).toBeDefined();\n *   // This data will be rolled back after the test\n * });\n * ```\n */\nexport class VitestObjectionTransactionIsolator extends VitestPostgresTransactionIsolator<\n  Knex,\n  Knex.Transaction\n> {\n  async destroy(conn: Knex<any, any[]>): Promise<void> {}\n  /**\n   * Creates a Knex transaction with the specified isolation level.\n   * Implements the abstract transact method from VitestPostgresTransactionIsolator.\n   * This transaction can be used with Objection.js models via Model.query(trx).\n   *\n   * @param conn - The Knex database connection\n   * @param level - 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   * @example\n   * ```typescript\n   * await isolator.transact(knex, IsolationLevel.REPEATABLE_READ, async (trx) => {\n   *   // Use transaction with Objection models\n   *   await User.query(trx).insert({ name: 'Test' });\n   *   await Post.query(trx).where('userId', user.id).delete();\n   * });\n   * ```\n   */\n  async transact(\n    connection: Knex,\n    level: IsolationLevel,\n    fn: (trx: Knex.Transaction) => Promise<void>,\n  ): Promise<void> {\n    const isolationLevel = level.toLowerCase() as Lowercase<IsolationLevel>;\n\n    await connection.transaction(\n      async (trx) => {\n        await fn(trx);\n      },\n      {\n        isolationLevel,\n      },\n    );\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkCA,IAAa,qCAAb,cAAwDA,oEAGtD;CACA,MAAM,QAAQC,MAAuC,CAAE;;;;;;;;;;;;;;;;;;;;CAoBvD,MAAM,SACJC,YACAC,OACAC,IACe;EACf,MAAM,iBAAiB,MAAM,aAAa;AAE1C,QAAM,WAAW,YACf,OAAO,QAAQ;AACb,SAAM,GAAG,IAAI;EACd,GACD,EACE,eACD,EACF;CACF;AACF"}
+{"version":3,"file":"VitestObjectionTransactionIsolator-CM5KTAFA.cjs","names":["VitestPostgresTransactionIsolator","conn: Knex<any, any[]>","connection: Knex","level: IsolationLevel","fn: (trx: Knex.Transaction) => Promise<void>"],"sources":["../src/VitestObjectionTransactionIsolator.ts"],"sourcesContent":["import type { Knex } from 'knex';\nimport {\n  type IsolationLevel,\n  VitestPostgresTransactionIsolator,\n} from './VitestTransactionIsolator';\n\n/**\n * Objection.js-specific implementation of the Vitest transaction isolator.\n * Provides automatic transaction rollback for test isolation using Objection.js and Knex transaction API.\n * Each test runs within a database transaction that is rolled back after completion,\n * ensuring a clean state between tests without the overhead of recreating data.\n *\n * @example\n * ```typescript\n * import { VitestObjectionTransactionIsolator } from '@geekmidas/testkit';\n * import { knex } from './database';\n * import { User } from './models';\n * import { test } from 'vitest';\n *\n * // Create isolator instance\n * const isolator = new VitestObjectionTransactionIsolator(test);\n *\n * // Use with wrapped test API\n * const isolatedTest = isolator.wrapVitestWithTransaction(knex);\n *\n * isolatedTest('should create user', async ({ trx }) => {\n *   const user = await User.query(trx)\n *     .insert({ name: 'Test User' });\n *\n *   expect(user).toBeDefined();\n *   // This data will be rolled back after the test\n * });\n * ```\n */\nexport class VitestObjectionTransactionIsolator extends VitestPostgresTransactionIsolator<\n  Knex,\n  Knex.Transaction\n> {\n  async destroy(conn: Knex<any, any[]>): Promise<void> {}\n  /**\n   * Creates a Knex transaction with the specified isolation level.\n   * Implements the abstract transact method from VitestPostgresTransactionIsolator.\n   * This transaction can be used with Objection.js models via Model.query(trx).\n   *\n   * @param conn - The Knex database connection\n   * @param level - 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   * @example\n   * ```typescript\n   * await isolator.transact(knex, IsolationLevel.REPEATABLE_READ, async (trx) => {\n   *   // Use transaction with Objection models\n   *   await User.query(trx).insert({ name: 'Test' });\n   *   await Post.query(trx).where('userId', user.id).delete();\n   * });\n   * ```\n   */\n  async transact(\n    connection: Knex,\n    level: IsolationLevel,\n    fn: (trx: Knex.Transaction) => Promise<void>,\n  ): Promise<void> {\n    const isolationLevel = level.toLowerCase() as Lowercase<IsolationLevel>;\n\n    await connection.transaction(\n      async (trx) => {\n        await fn(trx);\n      },\n      {\n        isolationLevel,\n      },\n    );\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkCA,IAAa,qCAAb,cAAwDA,oEAGtD;CACA,MAAM,QAAQC,MAAuC,CAAE;;;;;;;;;;;;;;;;;;;;CAoBvD,MAAM,SACJC,YACAC,OACAC,IACe;EACf,MAAM,iBAAiB,MAAM,aAAa;AAE1C,QAAM,WAAW,YACf,OAAO,QAAQ;AACb,SAAM,GAAG,IAAI;EACd,GACD,EACE,eACD,EACF;CACF;AACF"}

package/dist/{VitestObjectionTransactionIsolator-lZUSz1w0.d.mts → VitestObjectionTransactionIsolator-i9jIgU8Q.d.mts}

@@ -1,4 +1,4 @@
-import { IsolationLevel, VitestPostgresTransactionIsolator } from "./VitestTransactionIsolator-DWDbnITQ.mjs";
+import { IsolationLevel, VitestPostgresTransactionIsolator } from "./VitestTransactionIsolator-BvR19bYn.mjs";
 import { Knex } from "knex";
 
 //#region src/VitestObjectionTransactionIsolator.d.ts
@@ -56,4 +56,4 @@ declare class VitestObjectionTransactionIsolator extends VitestPostgresTransacti
 }
 //#endregion
 export { VitestObjectionTransactionIsolator };
-//# sourceMappingURL=VitestObjectionTransactionIsolator-lZUSz1w0.d.mts.map
+//# sourceMappingURL=VitestObjectionTransactionIsolator-i9jIgU8Q.d.mts.map

package/dist/{VitestObjectionTransactionIsolator-_EhJKu_O.mjs → VitestObjectionTransactionIsolator-jQFaCz0u.mjs}

@@ -1,4 +1,4 @@
-import { VitestPostgresTransactionIsolator } from "./VitestTransactionIsolator-BIaMs4c2.mjs";
+import { VitestPostgresTransactionIsolator } from "./VitestTransactionIsolator-DQ7tLqgV.mjs";
 
 //#region src/VitestObjectionTransactionIsolator.ts
 /**
@@ -60,4 +60,4 @@ var VitestObjectionTransactionIsolator = class extends VitestPostgresTransaction
 
 //#endregion
 export { VitestObjectionTransactionIsolator };
-//# sourceMappingURL=VitestObjectionTransactionIsolator-_EhJKu_O.mjs.map
+//# sourceMappingURL=VitestObjectionTransactionIsolator-jQFaCz0u.mjs.map

package/dist/{VitestObjectionTransactionIsolator-_EhJKu_O.mjs.map → VitestObjectionTransactionIsolator-jQFaCz0u.mjs.map}

@@ -1 +1 @@
-{"version":3,"file":"VitestObjectionTransactionIsolator-_EhJKu_O.mjs","names":["conn: Knex<any, any[]>","connection: Knex","level: IsolationLevel","fn: (trx: Knex.Transaction) => Promise<void>"],"sources":["../src/VitestObjectionTransactionIsolator.ts"],"sourcesContent":["import type { Knex } from 'knex';\nimport {\n  type IsolationLevel,\n  VitestPostgresTransactionIsolator,\n} from './VitestTransactionIsolator';\n\n/**\n * Objection.js-specific implementation of the Vitest transaction isolator.\n * Provides automatic transaction rollback for test isolation using Objection.js and Knex transaction API.\n * Each test runs within a database transaction that is rolled back after completion,\n * ensuring a clean state between tests without the overhead of recreating data.\n *\n * @example\n * ```typescript\n * import { VitestObjectionTransactionIsolator } from '@geekmidas/testkit';\n * import { knex } from './database';\n * import { User } from './models';\n * import { test } from 'vitest';\n *\n * // Create isolator instance\n * const isolator = new VitestObjectionTransactionIsolator(test);\n *\n * // Use with wrapped test API\n * const isolatedTest = isolator.wrapVitestWithTransaction(knex);\n *\n * isolatedTest('should create user', async ({ trx }) => {\n *   const user = await User.query(trx)\n *     .insert({ name: 'Test User' });\n *\n *   expect(user).toBeDefined();\n *   // This data will be rolled back after the test\n * });\n * ```\n */\nexport class VitestObjectionTransactionIsolator extends VitestPostgresTransactionIsolator<\n  Knex,\n  Knex.Transaction\n> {\n  async destroy(conn: Knex<any, any[]>): Promise<void> {}\n  /**\n   * Creates a Knex transaction with the specified isolation level.\n   * Implements the abstract transact method from VitestPostgresTransactionIsolator.\n   * This transaction can be used with Objection.js models via Model.query(trx).\n   *\n   * @param conn - The Knex database connection\n   * @param level - 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   * @example\n   * ```typescript\n   * await isolator.transact(knex, IsolationLevel.REPEATABLE_READ, async (trx) => {\n   *   // Use transaction with Objection models\n   *   await User.query(trx).insert({ name: 'Test' });\n   *   await Post.query(trx).where('userId', user.id).delete();\n   * });\n   * ```\n   */\n  async transact(\n    connection: Knex,\n    level: IsolationLevel,\n    fn: (trx: Knex.Transaction) => Promise<void>,\n  ): Promise<void> {\n    const isolationLevel = level.toLowerCase() as Lowercase<IsolationLevel>;\n\n    await connection.transaction(\n      async (trx) => {\n        await fn(trx);\n      },\n      {\n        isolationLevel,\n      },\n    );\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkCA,IAAa,qCAAb,cAAwD,kCAGtD;CACA,MAAM,QAAQA,MAAuC,CAAE;;;;;;;;;;;;;;;;;;;;CAoBvD,MAAM,SACJC,YACAC,OACAC,IACe;EACf,MAAM,iBAAiB,MAAM,aAAa;AAE1C,QAAM,WAAW,YACf,OAAO,QAAQ;AACb,SAAM,GAAG,IAAI;EACd,GACD,EACE,eACD,EACF;CACF;AACF"}
+{"version":3,"file":"VitestObjectionTransactionIsolator-jQFaCz0u.mjs","names":["conn: Knex<any, any[]>","connection: Knex","level: IsolationLevel","fn: (trx: Knex.Transaction) => Promise<void>"],"sources":["../src/VitestObjectionTransactionIsolator.ts"],"sourcesContent":["import type { Knex } from 'knex';\nimport {\n  type IsolationLevel,\n  VitestPostgresTransactionIsolator,\n} from './VitestTransactionIsolator';\n\n/**\n * Objection.js-specific implementation of the Vitest transaction isolator.\n * Provides automatic transaction rollback for test isolation using Objection.js and Knex transaction API.\n * Each test runs within a database transaction that is rolled back after completion,\n * ensuring a clean state between tests without the overhead of recreating data.\n *\n * @example\n * ```typescript\n * import { VitestObjectionTransactionIsolator } from '@geekmidas/testkit';\n * import { knex } from './database';\n * import { User } from './models';\n * import { test } from 'vitest';\n *\n * // Create isolator instance\n * const isolator = new VitestObjectionTransactionIsolator(test);\n *\n * // Use with wrapped test API\n * const isolatedTest = isolator.wrapVitestWithTransaction(knex);\n *\n * isolatedTest('should create user', async ({ trx }) => {\n *   const user = await User.query(trx)\n *     .insert({ name: 'Test User' });\n *\n *   expect(user).toBeDefined();\n *   // This data will be rolled back after the test\n * });\n * ```\n */\nexport class VitestObjectionTransactionIsolator extends VitestPostgresTransactionIsolator<\n  Knex,\n  Knex.Transaction\n> {\n  async destroy(conn: Knex<any, any[]>): Promise<void> {}\n  /**\n   * Creates a Knex transaction with the specified isolation level.\n   * Implements the abstract transact method from VitestPostgresTransactionIsolator.\n   * This transaction can be used with Objection.js models via Model.query(trx).\n   *\n   * @param conn - The Knex database connection\n   * @param level - 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   * @example\n   * ```typescript\n   * await isolator.transact(knex, IsolationLevel.REPEATABLE_READ, async (trx) => {\n   *   // Use transaction with Objection models\n   *   await User.query(trx).insert({ name: 'Test' });\n   *   await Post.query(trx).where('userId', user.id).delete();\n   * });\n   * ```\n   */\n  async transact(\n    connection: Knex,\n    level: IsolationLevel,\n    fn: (trx: Knex.Transaction) => Promise<void>,\n  ): Promise<void> {\n    const isolationLevel = level.toLowerCase() as Lowercase<IsolationLevel>;\n\n    await connection.transaction(\n      async (trx) => {\n        await fn(trx);\n      },\n      {\n        isolationLevel,\n      },\n    );\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkCA,IAAa,qCAAb,cAAwD,kCAGtD;CACA,MAAM,QAAQA,MAAuC,CAAE;;;;;;;;;;;;;;;;;;;;CAoBvD,MAAM,SACJC,YACAC,OACAC,IACe;EACf,MAAM,iBAAiB,MAAM,aAAa;AAE1C,QAAM,WAAW,YACf,OAAO,QAAQ;AACb,SAAM,GAAG,IAAI;EACd,GACD,EACE,eACD,EACF;CACF;AACF"}

package/dist/VitestObjectionTransactionIsolator.cjs

@@ -1,4 +1,4 @@
-require('./VitestTransactionIsolator-BKIrj3Uy.cjs');
-const require_VitestObjectionTransactionIsolator = require('./VitestObjectionTransactionIsolator-D_tlOtq8.cjs');
+require('./VitestTransactionIsolator-CMfJXZP8.cjs');
+const require_VitestObjectionTransactionIsolator = require('./VitestObjectionTransactionIsolator-CM5KTAFA.cjs');
 
 exports.VitestObjectionTransactionIsolator = require_VitestObjectionTransactionIsolator.VitestObjectionTransactionIsolator;

package/dist/VitestObjectionTransactionIsolator.d.cts

@@ -1,3 +1,3 @@
-import "./VitestTransactionIsolator-CyG_i_Nj.cjs";
-import { VitestObjectionTransactionIsolator } from "./VitestObjectionTransactionIsolator-COVDlpEo.cjs";
+import "./VitestTransactionIsolator-CwQaxZLP.cjs";
+import { VitestObjectionTransactionIsolator } from "./VitestObjectionTransactionIsolator-1TpsPqfG.cjs";
 export { VitestObjectionTransactionIsolator };

package/dist/VitestObjectionTransactionIsolator.d.mts

@@ -1,3 +1,3 @@
-import "./VitestTransactionIsolator-DWDbnITQ.mjs";
-import { VitestObjectionTransactionIsolator } from "./VitestObjectionTransactionIsolator-lZUSz1w0.mjs";
+import "./VitestTransactionIsolator-BvR19bYn.mjs";
+import { VitestObjectionTransactionIsolator } from "./VitestObjectionTransactionIsolator-i9jIgU8Q.mjs";
 export { VitestObjectionTransactionIsolator };

package/dist/VitestObjectionTransactionIsolator.mjs

@@ -1,4 +1,4 @@
-import "./VitestTransactionIsolator-BIaMs4c2.mjs";
-import { VitestObjectionTransactionIsolator } from "./VitestObjectionTransactionIsolator-_EhJKu_O.mjs";
+import "./VitestTransactionIsolator-DQ7tLqgV.mjs";
+import { VitestObjectionTransactionIsolator } from "./VitestObjectionTransactionIsolator-jQFaCz0u.mjs";
 
 export { VitestObjectionTransactionIsolator };

package/dist/{VitestTransactionIsolator-DWDbnITQ.d.mts → VitestTransactionIsolator-BvR19bYn.d.mts}

@@ -112,35 +112,61 @@ declare abstract class VitestPostgresTransactionIsolator<TConn, Transaction> {
    * 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)
+   * @param options - Configuration options for transaction wrapping
    * @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' });
+   * const isolatedTest = isolator.wrapVitestWithTransaction({
+   *   connection: db,
+   *   setup: async (trx) => {
+   *     await trx.insert('settings', { key: 'test', value: 'true' });
+   *   },
+   *   fixtures: {
+   *     factory: (trx) => new Factory(trx),
+   *   },
    * });
    *
-   * isolatedTest('test with transaction', async ({ trx }) => {
-   *   const user = await trx.insert('users', { name: 'Test' });
+   * isolatedTest('test with transaction', async ({ trx, factory }) => {
+   *   const user = await factory.insert('user', { name: 'Test' });
    *   expect(user).toBeDefined();
    * });
    * ```
    */
-  wrapVitestWithTransaction(createConnection: DatabaseConnection<TConn>, setup?: (trx: Transaction) => Promise<void>, level?: IsolationLevel): TestAPI<{
-    trx: Transaction;
-  }>;
+  wrapVitestWithTransaction<Extended extends Record<string, unknown> = {}>(options: TransactionWrapperOptions<TConn, Transaction, Extended>): TestAPI<DatabaseFixtures<Transaction, object> & Extended>;
 }
 type DatabaseConnectionFn<Conn> = () => Conn | Promise<Conn>;
 type DatabaseConnection<Conn> = DatabaseConnectionFn<Conn>;
+/**
+ * Options for wrapping Vitest tests with database transaction isolation.
+ */
+interface TransactionWrapperOptions<TConn, Transaction, Extended extends Record<string, unknown> = {}> {
+  /** Function that creates or returns a database connection */
+  connection: DatabaseConnection<TConn>;
+  /** Optional setup function to run within the transaction before each test */
+  setup?: (trx: Transaction) => Promise<void>;
+  /** Transaction isolation level (defaults to REPEATABLE_READ) */
+  isolationLevel?: IsolationLevel;
+  /** Additional fixtures that depend on the transaction */
+  fixtures?: FixtureCreators<Transaction, Extended>;
+}
 /**
  * Type for fixture creator functions that depend on the transaction.
  * Each function receives the transaction and returns the fixture value.
  */
 type FixtureCreators<Transaction, Extended extends Record<string, unknown>> = { [K in keyof Extended]: (trx: Transaction) => Extended[K] | Promise<Extended[K]> };
+/**
+ * The test API returned by extendWithFixtures.
+ * Provides access to both the transaction (trx) and all extended fixtures.
+ *
+ * @template Transaction - The transaction type
+ * @template Extended - The type of additional fixtures provided
+ * @template BaseTest - The base wrapped test type
+ */
+type TestWithExtendedFixtures<Transaction, Extended extends Record<string, unknown>, BaseTest extends ReturnType<TestAPI['extend']> = ReturnType<TestAPI['extend']>> = BaseTest & {
+  <C extends object>(name: string, fn: (context: DatabaseFixtures<Transaction> & Extended & C) => Promise<void>): void;
+  <C extends object>(name: string, options: object, fn: (context: DatabaseFixtures<Transaction> & Extended & C) => Promise<void>): void;
+};
 /**
  * Extends a wrapped test API with additional fixtures that depend on the transaction.
  * This allows composing test context with factories, repositories, or other helpers.
@@ -156,7 +182,10 @@ type FixtureCreators<Transaction, Extended extends Record<string, unknown>> = {
  * import { wrapVitestKyselyTransaction, extendWithFixtures } from '@geekmidas/testkit/kysely';
  *
  * // Create base wrapped test
- * const baseTest = wrapVitestKyselyTransaction(test, db, createTestTables);
+ * const baseTest = wrapVitestKyselyTransaction(test, {
+ *   connection: db,
+ *   setup: createTestTables,
+ * });
  *
  * // Extend with fixtures
  * const it = extendWithFixtures(baseTest, {
@@ -171,10 +200,7 @@ type FixtureCreators<Transaction, Extended extends Record<string, unknown>> = {
  * });
  * ```
  */
-declare function extendWithFixtures<Transaction, Extended extends Record<string, unknown>, T extends ReturnType<TestAPI['extend']> = any>(wrappedTest: T, fixtures: FixtureCreators<Transaction, Extended>): T & {
-  <C extends object>(name: string, fn: (context: DatabaseFixtures<Transaction> & Extended & C) => Promise<void>): void;
-  <C extends object>(name: string, options: object, fn: (context: DatabaseFixtures<Transaction> & Extended & C) => Promise<void>): void;
-};
+declare function extendWithFixtures<Transaction, Extended extends Record<string, unknown>, T extends ReturnType<TestAPI['extend']> = any>(wrappedTest: T, fixtures: FixtureCreators<Transaction, Extended>): TestWithExtendedFixtures<Transaction, Extended, T>;
 //#endregion
-export { DatabaseConnection, DatabaseConnectionFn, DatabaseFixtures, ExtendContextFn, ExtendedDatabaseFixtures, FixtureCreators, IsolationLevel, VitestPostgresTransactionIsolator, extendWithFixtures };
-//# sourceMappingURL=VitestTransactionIsolator-DWDbnITQ.d.mts.map
+export { DatabaseConnection, DatabaseConnectionFn, DatabaseFixtures, ExtendContextFn, ExtendedDatabaseFixtures, FixtureCreators, IsolationLevel, TestWithExtendedFixtures, TransactionWrapperOptions, VitestPostgresTransactionIsolator, extendWithFixtures };
+//# sourceMappingURL=VitestTransactionIsolator-BvR19bYn.d.mts.map