@geekmidas/testkit 0.1.0 → 0.1.1

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-DE3hE0WO.d.mts}

@@ -1,4 +1,4 @@
-import { FakerFactory } from "./faker-Cg76aFNO.cjs";
+import { FakerFactory } from "./faker-D9gz7KjY.mjs";
 
 //#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-DE3hE0WO.d.mts.map

package/dist/{Factory-Cmr3s3-s.d.mts → Factory-pNV7ZQ7-.d.cts}

@@ -1,4 +1,4 @@
-import { FakerFactory } from "./faker-DHh7xs4u.mjs";
+import { FakerFactory } from "./faker-BSH1EMtg.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-Cmr3s3-s.d.mts.map
+//# sourceMappingURL=Factory-pNV7ZQ7-.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-BSH1EMtg.cjs";
+import { Factory, FactorySeed, MixedFactoryBuilder } from "./Factory-pNV7ZQ7-.cjs";
 export { Factory, FactorySeed, MixedFactoryBuilder };

package/dist/Factory.d.mts

@@ -1,3 +1,3 @@
-import "./faker-DHh7xs4u.mjs";
-import { Factory, FactorySeed, MixedFactoryBuilder } from "./Factory-Cmr3s3-s.mjs";
+import "./faker-D9gz7KjY.mjs";
+import { Factory, FactorySeed, MixedFactoryBuilder } from "./Factory-DE3hE0WO.mjs";
 export { Factory, FactorySeed, MixedFactoryBuilder };

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

@@ -1,5 +1,5 @@
-import { FakerFactory } from "./faker-Cg76aFNO.cjs";
-import { Factory, FactorySeed } from "./Factory-BZ8uMoXl.cjs";
+import { FakerFactory } from "./faker-BSH1EMtg.cjs";
+import { Factory, FactorySeed } from "./Factory-pNV7ZQ7-.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-CPZTUuMB.d.cts.map

package/dist/{KyselyFactory-BTdygZ-i.d.mts → KyselyFactory-RAyvZ8Cj.d.mts}

@@ -1,5 +1,5 @@
-import { FakerFactory } from "./faker-DHh7xs4u.mjs";
-import { Factory, FactorySeed } from "./Factory-Cmr3s3-s.mjs";
+import { FakerFactory } from "./faker-D9gz7KjY.mjs";
+import { Factory, FactorySeed } from "./Factory-DE3hE0WO.mjs";
 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-BTdygZ-i.d.mts.map
+//# sourceMappingURL=KyselyFactory-RAyvZ8Cj.d.mts.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-BSH1EMtg.cjs";
+import "./Factory-pNV7ZQ7-.cjs";
+import { KyselyFactory } from "./KyselyFactory-CPZTUuMB.cjs";
 export { KyselyFactory };

package/dist/KyselyFactory.d.mts

@@ -1,4 +1,4 @@
-import "./faker-DHh7xs4u.mjs";
-import "./Factory-Cmr3s3-s.mjs";
-import { KyselyFactory } from "./KyselyFactory-BTdygZ-i.mjs";
+import "./faker-D9gz7KjY.mjs";
+import "./Factory-DE3hE0WO.mjs";
+import { KyselyFactory } from "./KyselyFactory-RAyvZ8Cj.mjs";
 export { KyselyFactory };

package/dist/{ObjectionFactory-BagGjikT.d.mts → ObjectionFactory-BlBicEia.d.mts}

@@ -1,5 +1,5 @@
-import { FakerFactory } from "./faker-DHh7xs4u.mjs";
-import { Factory, FactorySeed } from "./Factory-Cmr3s3-s.mjs";
+import { FakerFactory } from "./faker-D9gz7KjY.mjs";
+import { Factory, FactorySeed } from "./Factory-DE3hE0WO.mjs";
 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-BagGjikT.d.mts.map
+//# sourceMappingURL=ObjectionFactory-BlBicEia.d.mts.map

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

@@ -1,5 +1,5 @@
-import { FakerFactory } from "./faker-Cg76aFNO.cjs";
-import { Factory, FactorySeed } from "./Factory-BZ8uMoXl.cjs";
+import { FakerFactory } from "./faker-BSH1EMtg.cjs";
+import { Factory, FactorySeed } from "./Factory-pNV7ZQ7-.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-BwpN4gMX.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-BSH1EMtg.cjs";
+import "./Factory-pNV7ZQ7-.cjs";
+import { ObjectionFactory } from "./ObjectionFactory-BwpN4gMX.cjs";
 export { ObjectionFactory };

package/dist/ObjectionFactory.d.mts

@@ -1,4 +1,4 @@
-import "./faker-DHh7xs4u.mjs";
-import "./Factory-Cmr3s3-s.mjs";
-import { ObjectionFactory } from "./ObjectionFactory-BagGjikT.mjs";
+import "./faker-D9gz7KjY.mjs";
+import "./Factory-DE3hE0WO.mjs";
+import { ObjectionFactory } from "./ObjectionFactory-BlBicEia.mjs";
 export { ObjectionFactory };

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

@@ -1,4 +1,4 @@
-import { IsolationLevel, VitestPostgresTransactionIsolator } from "./VitestTransactionIsolator-CyG_i_Nj.cjs";
+import { IsolationLevel, VitestPostgresTransactionIsolator } from "./VitestTransactionIsolator-DfA80g2M.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-4HOeLQ0d.d.cts.map
+//# sourceMappingURL=VitestKyselyTransactionIsolator-BqrZDeaT.d.cts.map

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

@@ -1,4 +1,4 @@
-import { IsolationLevel, VitestPostgresTransactionIsolator } from "./VitestTransactionIsolator-DWDbnITQ.mjs";
+import { IsolationLevel, VitestPostgresTransactionIsolator } from "./VitestTransactionIsolator-DLdQlfZ5.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-DnyZMaA-.d.mts.map
+//# sourceMappingURL=VitestKyselyTransactionIsolator-DiskaURs.d.mts.map

package/dist/VitestKyselyTransactionIsolator.d.cts

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

package/dist/VitestKyselyTransactionIsolator.d.mts

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

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

@@ -1,4 +1,4 @@
-import { IsolationLevel, VitestPostgresTransactionIsolator } from "./VitestTransactionIsolator-CyG_i_Nj.cjs";
+import { IsolationLevel, VitestPostgresTransactionIsolator } from "./VitestTransactionIsolator-DfA80g2M.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-CD2ucJpH.d.cts.map

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

@@ -1,4 +1,4 @@
-import { IsolationLevel, VitestPostgresTransactionIsolator } from "./VitestTransactionIsolator-DWDbnITQ.mjs";
+import { IsolationLevel, VitestPostgresTransactionIsolator } from "./VitestTransactionIsolator-DLdQlfZ5.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-DhQ8XGva.d.mts.map

package/dist/VitestObjectionTransactionIsolator.d.cts

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

package/dist/VitestObjectionTransactionIsolator.d.mts

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

package/dist/VitestTransactionIsolator-BIaMs4c2.mjs.map

@@ -1 +1 @@
-{"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"}
+{"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 * The test API returned by extendWithFixtures.\n * Provides access to both the transaction (trx) and all extended fixtures.\n *\n * @template Transaction - The transaction type\n * @template Extended - The type of additional fixtures provided\n * @template BaseTest - The base wrapped test type\n */\nexport type TestWithExtendedFixtures<\n  Transaction,\n  Extended extends Record<string, unknown>,\n  BaseTest extends ReturnType<TestAPI['extend']> = ReturnType<\n    TestAPI['extend']\n  >,\n> = BaseTest & {\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\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): TestWithExtendedFixtures<Transaction, Extended, T> {\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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8ED,SAAgB,mBAMdC,aACAC,UACoD;CAEpD,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 +1 @@
-{"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"}
+{"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 * The test API returned by extendWithFixtures.\n * Provides access to both the transaction (trx) and all extended fixtures.\n *\n * @template Transaction - The transaction type\n * @template Extended - The type of additional fixtures provided\n * @template BaseTest - The base wrapped test type\n */\nexport type TestWithExtendedFixtures<\n  Transaction,\n  Extended extends Record<string, unknown>,\n  BaseTest extends ReturnType<TestAPI['extend']> = ReturnType<\n    TestAPI['extend']\n  >,\n> = BaseTest & {\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\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): TestWithExtendedFixtures<Transaction, Extended, T> {\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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8ED,SAAgB,mBAMdC,aACAC,UACoD;CAEpD,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-CyG_i_Nj.d.cts → VitestTransactionIsolator-DLdQlfZ5.d.mts}

@@ -141,6 +141,18 @@ type DatabaseConnection<Conn> = DatabaseConnectionFn<Conn>;
  * 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.
@@ -171,10 +183,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-CyG_i_Nj.d.cts.map
+export { DatabaseConnection, DatabaseConnectionFn, DatabaseFixtures, ExtendContextFn, ExtendedDatabaseFixtures, FixtureCreators, IsolationLevel, TestWithExtendedFixtures, VitestPostgresTransactionIsolator, extendWithFixtures };
+//# sourceMappingURL=VitestTransactionIsolator-DLdQlfZ5.d.mts.map

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

@@ -141,6 +141,18 @@ type DatabaseConnection<Conn> = DatabaseConnectionFn<Conn>;
  * 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.
@@ -171,10 +183,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, VitestPostgresTransactionIsolator, extendWithFixtures };
+//# sourceMappingURL=VitestTransactionIsolator-DfA80g2M.d.cts.map

package/dist/VitestTransactionIsolator.d.cts

@@ -1,2 +1,2 @@
-import { DatabaseConnection, DatabaseConnectionFn, DatabaseFixtures, ExtendContextFn, ExtendedDatabaseFixtures, FixtureCreators, IsolationLevel, VitestPostgresTransactionIsolator, extendWithFixtures } from "./VitestTransactionIsolator-CyG_i_Nj.cjs";
-export { DatabaseConnection, DatabaseConnectionFn, DatabaseFixtures, ExtendContextFn, ExtendedDatabaseFixtures, FixtureCreators, IsolationLevel, VitestPostgresTransactionIsolator, extendWithFixtures };
+import { DatabaseConnection, DatabaseConnectionFn, DatabaseFixtures, ExtendContextFn, ExtendedDatabaseFixtures, FixtureCreators, IsolationLevel, TestWithExtendedFixtures, VitestPostgresTransactionIsolator, extendWithFixtures } from "./VitestTransactionIsolator-DfA80g2M.cjs";
+export { DatabaseConnection, DatabaseConnectionFn, DatabaseFixtures, ExtendContextFn, ExtendedDatabaseFixtures, FixtureCreators, IsolationLevel, TestWithExtendedFixtures, VitestPostgresTransactionIsolator, extendWithFixtures };

package/dist/VitestTransactionIsolator.d.mts

@@ -1,2 +1,2 @@
-import { DatabaseConnection, DatabaseConnectionFn, DatabaseFixtures, ExtendContextFn, ExtendedDatabaseFixtures, FixtureCreators, IsolationLevel, VitestPostgresTransactionIsolator, extendWithFixtures } from "./VitestTransactionIsolator-DWDbnITQ.mjs";
-export { DatabaseConnection, DatabaseConnectionFn, DatabaseFixtures, ExtendContextFn, ExtendedDatabaseFixtures, FixtureCreators, IsolationLevel, VitestPostgresTransactionIsolator, extendWithFixtures };
+import { DatabaseConnection, DatabaseConnectionFn, DatabaseFixtures, ExtendContextFn, ExtendedDatabaseFixtures, FixtureCreators, IsolationLevel, TestWithExtendedFixtures, VitestPostgresTransactionIsolator, extendWithFixtures } from "./VitestTransactionIsolator-DLdQlfZ5.mjs";
+export { DatabaseConnection, DatabaseConnectionFn, DatabaseFixtures, ExtendContextFn, ExtendedDatabaseFixtures, FixtureCreators, IsolationLevel, TestWithExtendedFixtures, VitestPostgresTransactionIsolator, extendWithFixtures };

package/dist/better-auth.d.cts

@@ -1,4 +1,4 @@
-import * as better_auth_adapters0 from "better-auth/adapters";
+import * as better_auth_adapters1 from "better-auth/adapters";
 import { DBAdapterDebugLogOption } from "better-auth/adapters";
 
 //#region src/better-auth.d.ts
@@ -7,7 +7,7 @@ interface MemoryAdapterConfig {
   usePlural?: boolean;
   initialData?: Record<string, any[]>;
 }
-declare const memoryAdapter: (config?: MemoryAdapterConfig, store?: Map<any, any>) => better_auth_adapters0.AdapterFactory & {
+declare const memoryAdapter: (config?: MemoryAdapterConfig, store?: Map<any, any>) => better_auth_adapters1.AdapterFactory & {
   clear: () => void;
   getAllData: () => Record<string, any[]>;
   getStore: () => Map<any, any>;

package/dist/better-auth.d.mts

@@ -1,4 +1,4 @@
-import * as better_auth_adapters0 from "better-auth/adapters";
+import * as better_auth_adapters4 from "better-auth/adapters";
 import { DBAdapterDebugLogOption } from "better-auth/adapters";
 
 //#region src/better-auth.d.ts
@@ -7,7 +7,7 @@ interface MemoryAdapterConfig {
   usePlural?: boolean;
   initialData?: Record<string, any[]>;
 }
-declare const memoryAdapter: (config?: MemoryAdapterConfig, store?: Map<any, any>) => better_auth_adapters0.AdapterFactory & {
+declare const memoryAdapter: (config?: MemoryAdapterConfig, store?: Map<any, any>) => better_auth_adapters4.AdapterFactory & {
   clear: () => void;
   getAllData: () => Record<string, any[]>;
   getStore: () => Map<any, any>;

package/dist/{directory-BXavAeJZ.d.mts → directory-Mi7tdOuD.d.cts}

@@ -1,7 +1,7 @@
-import * as vitest6 from "vitest";
+import * as vitest4 from "vitest";
 
 //#region src/os/directory.d.ts
-declare const itWithDir: vitest6.TestAPI<{
+declare const itWithDir: vitest4.TestAPI<{
   dir: string;
 }>;
 interface DirectoryFixtures {
@@ -9,4 +9,4 @@ interface DirectoryFixtures {
 }
 //#endregion
 export { DirectoryFixtures, itWithDir };
-//# sourceMappingURL=directory-BXavAeJZ.d.mts.map
+//# sourceMappingURL=directory-Mi7tdOuD.d.cts.map

package/dist/{directory-DlkPEzL4.d.cts → directory-Q178x53k.d.mts}

@@ -1,7 +1,7 @@
-import * as vitest6 from "vitest";
+import * as vitest3 from "vitest";
 
 //#region src/os/directory.d.ts
-declare const itWithDir: vitest6.TestAPI<{
+declare const itWithDir: vitest3.TestAPI<{
   dir: string;
 }>;
 interface DirectoryFixtures {
@@ -9,4 +9,4 @@ interface DirectoryFixtures {
 }
 //#endregion
 export { DirectoryFixtures, itWithDir };
-//# sourceMappingURL=directory-DlkPEzL4.d.cts.map
+//# sourceMappingURL=directory-Q178x53k.d.mts.map

package/dist/{faker-Cg76aFNO.d.cts → faker-BSH1EMtg.d.cts}

@@ -1,4 +1,4 @@
-import * as _faker_js_faker1 from "@faker-js/faker";
+import * as _faker_js_faker0 from "@faker-js/faker";
 
 //#region src/faker.d.ts
 
@@ -134,7 +134,7 @@ declare function coordinateOutsideRadius(center: Coordinate, minRadiusMeters: nu
  * const productPrice = faker.price();
  * ```
  */
-declare const faker: Readonly<_faker_js_faker1.Faker & {
+declare const faker: Readonly<_faker_js_faker0.Faker & {
   timestamps: typeof timestamps;
   identifier: typeof identifier;
   sequence: typeof sequence;
@@ -163,4 +163,4 @@ type Timestamps = {
 type FakerFactory = typeof faker;
 //#endregion
 export { FakerFactory, Timestamps, coordinateInRadius, faker, identifier, resetAllSequences, resetSequence, sequence, timestamps };
-//# sourceMappingURL=faker-Cg76aFNO.d.cts.map
+//# sourceMappingURL=faker-BSH1EMtg.d.cts.map

package/dist/{faker-DHh7xs4u.d.mts → faker-D9gz7KjY.d.mts}

@@ -1,4 +1,4 @@
-import * as _faker_js_faker1 from "@faker-js/faker";
+import * as _faker_js_faker0 from "@faker-js/faker";
 
 //#region src/faker.d.ts
 
@@ -134,7 +134,7 @@ declare function coordinateOutsideRadius(center: Coordinate, minRadiusMeters: nu
  * const productPrice = faker.price();
  * ```
  */
-declare const faker$1: Readonly<_faker_js_faker1.Faker & {
+declare const faker$1: Readonly<_faker_js_faker0.Faker & {
   timestamps: typeof timestamps;
   identifier: typeof identifier;
   sequence: typeof sequence;
@@ -163,4 +163,4 @@ type Timestamps = {
 type FakerFactory = typeof faker$1;
 //#endregion
 export { FakerFactory, Timestamps, coordinateInRadius, faker$1 as faker, identifier, resetAllSequences, resetSequence, sequence, timestamps };
-//# sourceMappingURL=faker-DHh7xs4u.d.mts.map
+//# sourceMappingURL=faker-D9gz7KjY.d.mts.map

package/dist/faker.d.cts

@@ -1,2 +1,2 @@
-import { FakerFactory, Timestamps, coordinateInRadius, faker, identifier, resetAllSequences, resetSequence, sequence, timestamps } from "./faker-Cg76aFNO.cjs";
+import { FakerFactory, Timestamps, coordinateInRadius, faker, identifier, resetAllSequences, resetSequence, sequence, timestamps } from "./faker-BSH1EMtg.cjs";
 export { FakerFactory, Timestamps, coordinateInRadius, faker, identifier, resetAllSequences, resetSequence, sequence, timestamps };

package/dist/faker.d.mts

@@ -1,2 +1,2 @@
-import { FakerFactory, Timestamps, coordinateInRadius, faker, identifier, resetAllSequences, resetSequence, sequence, timestamps } from "./faker-DHh7xs4u.mjs";
+import { FakerFactory, Timestamps, coordinateInRadius, faker, identifier, resetAllSequences, resetSequence, sequence, timestamps } from "./faker-D9gz7KjY.mjs";
 export { FakerFactory, Timestamps, coordinateInRadius, faker, identifier, resetAllSequences, resetSequence, sequence, timestamps };

package/dist/kysely.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"kysely.cjs","names":["api: TestAPI","connection: DatabaseConnection<Kysely<Database>>","setup?: (trx: Transaction<Database>) => Promise<void>","level: IsolationLevel","IsolationLevel","VitestKyselyTransactionIsolator","extendWithFixtures","wrappedTest: T","fixtures: FixtureCreators<Transaction<Database>, Extended>"],"sources":["../src/kysely.ts"],"sourcesContent":["import type { Kysely, Transaction } from 'kysely';\nimport type { TestAPI } from 'vitest';\nimport { VitestKyselyTransactionIsolator } from './VitestKyselyTransactionIsolator';\nimport {\n  type DatabaseConnection,\n  type FixtureCreators,\n  IsolationLevel,\n  extendWithFixtures as baseExtendWithFixtures,\n} from './VitestTransactionIsolator';\n\n/**\n * Kysely-specific exports for test utilities.\n * Provides factories, migrators, and transaction isolators for Kysely ORM.\n */\n\nexport { KyselyFactory } from './KyselyFactory';\nexport { PostgresKyselyMigrator } from './PostgresKyselyMigrator';\nexport { VitestKyselyTransactionIsolator } from './VitestKyselyTransactionIsolator';\nexport { IsolationLevel } from './VitestTransactionIsolator';\nexport type { FixtureCreators } from './VitestTransactionIsolator';\n\n// Re-export faker and FakerFactory for type portability in declaration files\nexport { faker, type FakerFactory } from './faker';\n\n/**\n * Creates a wrapped Vitest test API with automatic transaction rollback for Kysely.\n * Each test runs in an isolated database transaction that is rolled back after completion.\n * This ensures tests don't affect each other's data and run faster than truncating tables.\n *\n * @template Database - The database schema type\n * @param api - The Vitest test API (usually `test` from vitest)\n * @param db - The Kysely database instance\n * @param setup - Optional setup function to run before each test in the transaction\n * @param level - Transaction isolation level (defaults to REPEATABLE_READ)\n * @returns A wrapped test API that provides transaction isolation\n *\n * @example\n * ```typescript\n * import { test } from 'vitest';\n * import { wrapVitestKyselyTransaction } from '@geekmidas/testkit/kysely';\n * import { db } from './database';\n *\n * // Create isolated test with automatic rollback\n * const isolatedTest = wrapVitestKyselyTransaction(test, db);\n *\n * // Use in tests - each test gets its own transaction\n * isolatedTest('should create user', async ({ trx }) => {\n *   const user = await trx\n *     .insertInto('users')\n *     .values({ name: 'Test User', email: 'test@example.com' })\n *     .returningAll()\n *     .executeTakeFirst();\n *\n *   expect(user).toBeDefined();\n *   // User is automatically rolled back after test\n * });\n *\n * // With setup function for common test data\n * const testWithSetup = wrapVitestKyselyTransaction(\n *   test,\n *   db,\n *   async (trx) => {\n *     // Create common test data\n *     await trx.insertInto('settings')\n *       .values({ key: 'test_mode', value: 'true' })\n *       .execute();\n *   }\n * );\n *\n * testWithSetup('should have test settings', async ({ trx }) => {\n *   const setting = await trx\n *     .selectFrom('settings')\n *     .where('key', '=', 'test_mode')\n *     .selectAll()\n *     .executeTakeFirst();\n *\n *   expect(setting?.value).toBe('true');\n * });\n * ```\n */\nexport function wrapVitestKyselyTransaction<Database>(\n  api: TestAPI,\n  connection: DatabaseConnection<Kysely<Database>>,\n  setup?: (trx: Transaction<Database>) => Promise<void>,\n  level: IsolationLevel = IsolationLevel.REPEATABLE_READ,\n) {\n  const wrapper = new VitestKyselyTransactionIsolator<Database>(api);\n\n  return wrapper.wrapVitestWithTransaction(connection, setup, level);\n}\n\n/**\n * Extends a Kysely transaction-wrapped test with additional fixtures.\n * Each fixture receives the transaction and can create dependencies like factories or repositories.\n *\n * @template Database - The database schema type\n * @template Extended - The type of additional fixtures to provide\n * @param wrappedTest - The base wrapped test from wrapVitestKyselyTransaction\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 { test } from 'vitest';\n * import { wrapVitestKyselyTransaction, extendWithFixtures, KyselyFactory } from '@geekmidas/testkit/kysely';\n *\n * // Define your builders\n * const builders = {\n *   user: KyselyFactory.createBuilder<DB, 'users'>('users', ({ faker }) => ({\n *     name: faker.person.fullName(),\n *     email: faker.internet.email(),\n *   })),\n * };\n *\n * // Create base wrapped test\n * const baseTest = wrapVitestKyselyTransaction<DB>(test, db, createTestTables);\n *\n * // Extend with fixtures - each fixture receives the transaction\n * const it = extendWithFixtures<DB, { factory: KyselyFactory<DB, typeof builders, {}> }>(\n *   baseTest,\n *   {\n *     factory: (trx) => new KyselyFactory(builders, {}, trx),\n *   }\n * );\n *\n * // Use in tests - both trx and factory are available\n * it('should create user with factory', async ({ trx, factory }) => {\n *   const user = await factory.insert('user', { name: 'Test User' });\n *   expect(user.id).toBeDefined();\n *\n *   // Verify in database\n *   const found = await trx\n *     .selectFrom('users')\n *     .where('id', '=', user.id)\n *     .selectAll()\n *     .executeTakeFirst();\n *   expect(found?.name).toBe('Test User');\n * });\n * ```\n */\nexport function extendWithFixtures<\n  Database,\n  Extended extends Record<string, unknown>,\n  T extends ReturnType<TestAPI['extend']> = ReturnType<TestAPI['extend']>,\n>(wrappedTest: T, fixtures: FixtureCreators<Transaction<Database>, Extended>) {\n  return baseExtendWithFixtures<Transaction<Database>, Extended, T>(\n    wrappedTest,\n    fixtures,\n  );\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgFA,SAAgB,4BACdA,KACAC,YACAC,OACAC,QAAwBC,iDAAe,iBACvC;CACA,MAAM,UAAU,IAAIC,wEAA0C;AAE9D,QAAO,QAAQ,0BAA0B,YAAY,OAAO,MAAM;AACnE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAmDD,SAAgBC,qBAIdC,aAAgBC,UAA4D;AAC5E,QAAO,qDACL,aACA,SACD;AACF"}
+{"version":3,"file":"kysely.cjs","names":["api: TestAPI","connection: DatabaseConnection<Kysely<Database>>","setup?: (trx: Transaction<Database>) => Promise<void>","level: IsolationLevel","IsolationLevel","VitestKyselyTransactionIsolator","extendWithFixtures","wrappedTest: T","fixtures: FixtureCreators<Transaction<Database>, Extended>"],"sources":["../src/kysely.ts"],"sourcesContent":["import type { Kysely, Transaction } from 'kysely';\nimport type { TestAPI } from 'vitest';\nimport { VitestKyselyTransactionIsolator } from './VitestKyselyTransactionIsolator';\nimport {\n  type DatabaseConnection,\n  type FixtureCreators,\n  IsolationLevel,\n  extendWithFixtures as baseExtendWithFixtures,\n} from './VitestTransactionIsolator';\n\n/**\n * Kysely-specific exports for test utilities.\n * Provides factories, migrators, and transaction isolators for Kysely ORM.\n */\n\nexport { KyselyFactory } from './KyselyFactory';\nexport { PostgresKyselyMigrator } from './PostgresKyselyMigrator';\nexport { VitestKyselyTransactionIsolator } from './VitestKyselyTransactionIsolator';\nexport { IsolationLevel } from './VitestTransactionIsolator';\nexport type {\n  DatabaseFixtures,\n  ExtendedDatabaseFixtures,\n  FixtureCreators,\n  TestWithExtendedFixtures,\n} from './VitestTransactionIsolator';\n\n// Re-export faker and FakerFactory for type portability in declaration files\nexport { faker, type FakerFactory } from './faker';\n\n/**\n * Creates a wrapped Vitest test API with automatic transaction rollback for Kysely.\n * Each test runs in an isolated database transaction that is rolled back after completion.\n * This ensures tests don't affect each other's data and run faster than truncating tables.\n *\n * @template Database - The database schema type\n * @param api - The Vitest test API (usually `test` from vitest)\n * @param db - The Kysely database instance\n * @param setup - Optional setup function to run before each test in the transaction\n * @param level - Transaction isolation level (defaults to REPEATABLE_READ)\n * @returns A wrapped test API that provides transaction isolation\n *\n * @example\n * ```typescript\n * import { test } from 'vitest';\n * import { wrapVitestKyselyTransaction } from '@geekmidas/testkit/kysely';\n * import { db } from './database';\n *\n * // Create isolated test with automatic rollback\n * const isolatedTest = wrapVitestKyselyTransaction(test, db);\n *\n * // Use in tests - each test gets its own transaction\n * isolatedTest('should create user', async ({ trx }) => {\n *   const user = await trx\n *     .insertInto('users')\n *     .values({ name: 'Test User', email: 'test@example.com' })\n *     .returningAll()\n *     .executeTakeFirst();\n *\n *   expect(user).toBeDefined();\n *   // User is automatically rolled back after test\n * });\n *\n * // With setup function for common test data\n * const testWithSetup = wrapVitestKyselyTransaction(\n *   test,\n *   db,\n *   async (trx) => {\n *     // Create common test data\n *     await trx.insertInto('settings')\n *       .values({ key: 'test_mode', value: 'true' })\n *       .execute();\n *   }\n * );\n *\n * testWithSetup('should have test settings', async ({ trx }) => {\n *   const setting = await trx\n *     .selectFrom('settings')\n *     .where('key', '=', 'test_mode')\n *     .selectAll()\n *     .executeTakeFirst();\n *\n *   expect(setting?.value).toBe('true');\n * });\n * ```\n */\nexport function wrapVitestKyselyTransaction<Database>(\n  api: TestAPI,\n  connection: DatabaseConnection<Kysely<Database>>,\n  setup?: (trx: Transaction<Database>) => Promise<void>,\n  level: IsolationLevel = IsolationLevel.REPEATABLE_READ,\n) {\n  const wrapper = new VitestKyselyTransactionIsolator<Database>(api);\n\n  return wrapper.wrapVitestWithTransaction(connection, setup, level);\n}\n\n/**\n * Extends a Kysely transaction-wrapped test with additional fixtures.\n * Each fixture receives the transaction and can create dependencies like factories or repositories.\n *\n * @template Database - The database schema type\n * @template Extended - The type of additional fixtures to provide\n * @param wrappedTest - The base wrapped test from wrapVitestKyselyTransaction\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 { test } from 'vitest';\n * import { wrapVitestKyselyTransaction, extendWithFixtures, KyselyFactory } from '@geekmidas/testkit/kysely';\n *\n * // Define your builders\n * const builders = {\n *   user: KyselyFactory.createBuilder<DB, 'users'>('users', ({ faker }) => ({\n *     name: faker.person.fullName(),\n *     email: faker.internet.email(),\n *   })),\n * };\n *\n * // Create base wrapped test\n * const baseTest = wrapVitestKyselyTransaction<DB>(test, db, createTestTables);\n *\n * // Extend with fixtures - each fixture receives the transaction\n * const it = extendWithFixtures<DB, { factory: KyselyFactory<DB, typeof builders, {}> }>(\n *   baseTest,\n *   {\n *     factory: (trx) => new KyselyFactory(builders, {}, trx),\n *   }\n * );\n *\n * // Use in tests - both trx and factory are available\n * it('should create user with factory', async ({ trx, factory }) => {\n *   const user = await factory.insert('user', { name: 'Test User' });\n *   expect(user.id).toBeDefined();\n *\n *   // Verify in database\n *   const found = await trx\n *     .selectFrom('users')\n *     .where('id', '=', user.id)\n *     .selectAll()\n *     .executeTakeFirst();\n *   expect(found?.name).toBe('Test User');\n * });\n * ```\n */\nexport function extendWithFixtures<\n  Database,\n  Extended extends Record<string, unknown>,\n  T extends ReturnType<TestAPI['extend']> = ReturnType<TestAPI['extend']>,\n>(wrappedTest: T, fixtures: FixtureCreators<Transaction<Database>, Extended>) {\n  return baseExtendWithFixtures<Transaction<Database>, Extended, T>(\n    wrappedTest,\n    fixtures,\n  );\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAqFA,SAAgB,4BACdA,KACAC,YACAC,OACAC,QAAwBC,iDAAe,iBACvC;CACA,MAAM,UAAU,IAAIC,wEAA0C;AAE9D,QAAO,QAAQ,0BAA0B,YAAY,OAAO,MAAM;AACnE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAmDD,SAAgBC,qBAIdC,aAAgBC,UAA4D;AAC5E,QAAO,qDACL,aACA,SACD;AACF"}

package/dist/kysely.d.cts

@@ -1,10 +1,10 @@
-import { FakerFactory, faker } from "./faker-Cg76aFNO.cjs";
-import "./Factory-BZ8uMoXl.cjs";
-import { KyselyFactory } from "./KyselyFactory-BFygzOlO.cjs";
+import { FakerFactory, faker } from "./faker-BSH1EMtg.cjs";
+import "./Factory-pNV7ZQ7-.cjs";
+import { KyselyFactory } from "./KyselyFactory-CPZTUuMB.cjs";
 import "./PostgresMigrator-D5UkK1_K.cjs";
 import { PostgresKyselyMigrator } from "./PostgresKyselyMigrator-CQ3aUoy_.cjs";
-import { DatabaseConnection, DatabaseFixtures, FixtureCreators, IsolationLevel } from "./VitestTransactionIsolator-CyG_i_Nj.cjs";
-import { VitestKyselyTransactionIsolator } from "./VitestKyselyTransactionIsolator-4HOeLQ0d.cjs";
+import { DatabaseConnection, DatabaseFixtures, ExtendedDatabaseFixtures, FixtureCreators, IsolationLevel, TestWithExtendedFixtures } from "./VitestTransactionIsolator-DfA80g2M.cjs";
+import { VitestKyselyTransactionIsolator } from "./VitestKyselyTransactionIsolator-BqrZDeaT.cjs";
 import { Kysely, Transaction } from "kysely";
 import { TestAPI } from "vitest";
 
@@ -118,10 +118,7 @@ declare function wrapVitestKyselyTransaction<Database>(api: TestAPI, connection:
  * });
  * ```
  */
-declare function extendWithFixtures<Database, Extended extends Record<string, unknown>, T extends ReturnType<TestAPI['extend']> = ReturnType<TestAPI['extend']>>(wrappedTest: T, fixtures: FixtureCreators<Transaction<Database>, Extended>): T & {
-  <C extends object>(name: string, fn: (context: DatabaseFixtures<Transaction<Database>, object> & Extended & C) => Promise<void>): void;
-  <C extends object>(name: string, options: object, fn: (context: DatabaseFixtures<Transaction<Database>, object> & Extended & C) => Promise<void>): void;
-};
+declare function extendWithFixtures<Database, Extended extends Record<string, unknown>, T extends ReturnType<TestAPI['extend']> = ReturnType<TestAPI['extend']>>(wrappedTest: T, fixtures: FixtureCreators<Transaction<Database>, Extended>): TestWithExtendedFixtures<Transaction<Database>, Extended, T>;
 //#endregion
-export { FakerFactory, FixtureCreators, IsolationLevel, KyselyFactory, PostgresKyselyMigrator, VitestKyselyTransactionIsolator, extendWithFixtures, faker, wrapVitestKyselyTransaction };
+export { DatabaseFixtures, ExtendedDatabaseFixtures, FakerFactory, FixtureCreators, IsolationLevel, KyselyFactory, PostgresKyselyMigrator, TestWithExtendedFixtures, VitestKyselyTransactionIsolator, extendWithFixtures, faker, wrapVitestKyselyTransaction };
 //# sourceMappingURL=kysely.d.cts.map

package/dist/kysely.d.mts

@@ -1,10 +1,10 @@
-import { FakerFactory, faker } from "./faker-DHh7xs4u.mjs";
-import "./Factory-Cmr3s3-s.mjs";
-import { KyselyFactory } from "./KyselyFactory-BTdygZ-i.mjs";
+import { FakerFactory, faker } from "./faker-D9gz7KjY.mjs";
+import "./Factory-DE3hE0WO.mjs";
+import { KyselyFactory } from "./KyselyFactory-RAyvZ8Cj.mjs";
 import "./PostgresMigrator-DQaRxoaY.mjs";
 import { PostgresKyselyMigrator } from "./PostgresKyselyMigrator-CIx3AFSR.mjs";
-import { DatabaseConnection, DatabaseFixtures, FixtureCreators, IsolationLevel } from "./VitestTransactionIsolator-DWDbnITQ.mjs";
-import { VitestKyselyTransactionIsolator } from "./VitestKyselyTransactionIsolator-DnyZMaA-.mjs";
+import { DatabaseConnection, DatabaseFixtures, ExtendedDatabaseFixtures, FixtureCreators, IsolationLevel, TestWithExtendedFixtures } from "./VitestTransactionIsolator-DLdQlfZ5.mjs";
+import { VitestKyselyTransactionIsolator } from "./VitestKyselyTransactionIsolator-DiskaURs.mjs";
 import { Kysely, Transaction } from "kysely";
 import { TestAPI } from "vitest";
 
@@ -118,10 +118,7 @@ declare function wrapVitestKyselyTransaction<Database>(api: TestAPI, connection:
  * });
  * ```
  */
-declare function extendWithFixtures<Database, Extended extends Record<string, unknown>, T extends ReturnType<TestAPI['extend']> = ReturnType<TestAPI['extend']>>(wrappedTest: T, fixtures: FixtureCreators<Transaction<Database>, Extended>): T & {
-  <C extends object>(name: string, fn: (context: DatabaseFixtures<Transaction<Database>, object> & Extended & C) => Promise<void>): void;
-  <C extends object>(name: string, options: object, fn: (context: DatabaseFixtures<Transaction<Database>, object> & Extended & C) => Promise<void>): void;
-};
+declare function extendWithFixtures<Database, Extended extends Record<string, unknown>, T extends ReturnType<TestAPI['extend']> = ReturnType<TestAPI['extend']>>(wrappedTest: T, fixtures: FixtureCreators<Transaction<Database>, Extended>): TestWithExtendedFixtures<Transaction<Database>, Extended, T>;
 //#endregion
-export { FakerFactory, FixtureCreators, IsolationLevel, KyselyFactory, PostgresKyselyMigrator, VitestKyselyTransactionIsolator, extendWithFixtures, faker, wrapVitestKyselyTransaction };
+export { DatabaseFixtures, ExtendedDatabaseFixtures, FakerFactory, FixtureCreators, IsolationLevel, KyselyFactory, PostgresKyselyMigrator, TestWithExtendedFixtures, VitestKyselyTransactionIsolator, extendWithFixtures, faker, wrapVitestKyselyTransaction };
 //# sourceMappingURL=kysely.d.mts.map

package/dist/kysely.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"kysely.mjs","names":["api: TestAPI","connection: DatabaseConnection<Kysely<Database>>","setup?: (trx: Transaction<Database>) => Promise<void>","level: IsolationLevel","extendWithFixtures","wrappedTest: T","fixtures: FixtureCreators<Transaction<Database>, Extended>"],"sources":["../src/kysely.ts"],"sourcesContent":["import type { Kysely, Transaction } from 'kysely';\nimport type { TestAPI } from 'vitest';\nimport { VitestKyselyTransactionIsolator } from './VitestKyselyTransactionIsolator';\nimport {\n  type DatabaseConnection,\n  type FixtureCreators,\n  IsolationLevel,\n  extendWithFixtures as baseExtendWithFixtures,\n} from './VitestTransactionIsolator';\n\n/**\n * Kysely-specific exports for test utilities.\n * Provides factories, migrators, and transaction isolators for Kysely ORM.\n */\n\nexport { KyselyFactory } from './KyselyFactory';\nexport { PostgresKyselyMigrator } from './PostgresKyselyMigrator';\nexport { VitestKyselyTransactionIsolator } from './VitestKyselyTransactionIsolator';\nexport { IsolationLevel } from './VitestTransactionIsolator';\nexport type { FixtureCreators } from './VitestTransactionIsolator';\n\n// Re-export faker and FakerFactory for type portability in declaration files\nexport { faker, type FakerFactory } from './faker';\n\n/**\n * Creates a wrapped Vitest test API with automatic transaction rollback for Kysely.\n * Each test runs in an isolated database transaction that is rolled back after completion.\n * This ensures tests don't affect each other's data and run faster than truncating tables.\n *\n * @template Database - The database schema type\n * @param api - The Vitest test API (usually `test` from vitest)\n * @param db - The Kysely database instance\n * @param setup - Optional setup function to run before each test in the transaction\n * @param level - Transaction isolation level (defaults to REPEATABLE_READ)\n * @returns A wrapped test API that provides transaction isolation\n *\n * @example\n * ```typescript\n * import { test } from 'vitest';\n * import { wrapVitestKyselyTransaction } from '@geekmidas/testkit/kysely';\n * import { db } from './database';\n *\n * // Create isolated test with automatic rollback\n * const isolatedTest = wrapVitestKyselyTransaction(test, db);\n *\n * // Use in tests - each test gets its own transaction\n * isolatedTest('should create user', async ({ trx }) => {\n *   const user = await trx\n *     .insertInto('users')\n *     .values({ name: 'Test User', email: 'test@example.com' })\n *     .returningAll()\n *     .executeTakeFirst();\n *\n *   expect(user).toBeDefined();\n *   // User is automatically rolled back after test\n * });\n *\n * // With setup function for common test data\n * const testWithSetup = wrapVitestKyselyTransaction(\n *   test,\n *   db,\n *   async (trx) => {\n *     // Create common test data\n *     await trx.insertInto('settings')\n *       .values({ key: 'test_mode', value: 'true' })\n *       .execute();\n *   }\n * );\n *\n * testWithSetup('should have test settings', async ({ trx }) => {\n *   const setting = await trx\n *     .selectFrom('settings')\n *     .where('key', '=', 'test_mode')\n *     .selectAll()\n *     .executeTakeFirst();\n *\n *   expect(setting?.value).toBe('true');\n * });\n * ```\n */\nexport function wrapVitestKyselyTransaction<Database>(\n  api: TestAPI,\n  connection: DatabaseConnection<Kysely<Database>>,\n  setup?: (trx: Transaction<Database>) => Promise<void>,\n  level: IsolationLevel = IsolationLevel.REPEATABLE_READ,\n) {\n  const wrapper = new VitestKyselyTransactionIsolator<Database>(api);\n\n  return wrapper.wrapVitestWithTransaction(connection, setup, level);\n}\n\n/**\n * Extends a Kysely transaction-wrapped test with additional fixtures.\n * Each fixture receives the transaction and can create dependencies like factories or repositories.\n *\n * @template Database - The database schema type\n * @template Extended - The type of additional fixtures to provide\n * @param wrappedTest - The base wrapped test from wrapVitestKyselyTransaction\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 { test } from 'vitest';\n * import { wrapVitestKyselyTransaction, extendWithFixtures, KyselyFactory } from '@geekmidas/testkit/kysely';\n *\n * // Define your builders\n * const builders = {\n *   user: KyselyFactory.createBuilder<DB, 'users'>('users', ({ faker }) => ({\n *     name: faker.person.fullName(),\n *     email: faker.internet.email(),\n *   })),\n * };\n *\n * // Create base wrapped test\n * const baseTest = wrapVitestKyselyTransaction<DB>(test, db, createTestTables);\n *\n * // Extend with fixtures - each fixture receives the transaction\n * const it = extendWithFixtures<DB, { factory: KyselyFactory<DB, typeof builders, {}> }>(\n *   baseTest,\n *   {\n *     factory: (trx) => new KyselyFactory(builders, {}, trx),\n *   }\n * );\n *\n * // Use in tests - both trx and factory are available\n * it('should create user with factory', async ({ trx, factory }) => {\n *   const user = await factory.insert('user', { name: 'Test User' });\n *   expect(user.id).toBeDefined();\n *\n *   // Verify in database\n *   const found = await trx\n *     .selectFrom('users')\n *     .where('id', '=', user.id)\n *     .selectAll()\n *     .executeTakeFirst();\n *   expect(found?.name).toBe('Test User');\n * });\n * ```\n */\nexport function extendWithFixtures<\n  Database,\n  Extended extends Record<string, unknown>,\n  T extends ReturnType<TestAPI['extend']> = ReturnType<TestAPI['extend']>,\n>(wrappedTest: T, fixtures: FixtureCreators<Transaction<Database>, Extended>) {\n  return baseExtendWithFixtures<Transaction<Database>, Extended, T>(\n    wrappedTest,\n    fixtures,\n  );\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgFA,SAAgB,4BACdA,KACAC,YACAC,OACAC,QAAwB,eAAe,iBACvC;CACA,MAAM,UAAU,IAAI,gCAA0C;AAE9D,QAAO,QAAQ,0BAA0B,YAAY,OAAO,MAAM;AACnE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAmDD,SAAgBC,qBAIdC,aAAgBC,UAA4D;AAC5E,QAAO,mBACL,aACA,SACD;AACF"}
+{"version":3,"file":"kysely.mjs","names":["api: TestAPI","connection: DatabaseConnection<Kysely<Database>>","setup?: (trx: Transaction<Database>) => Promise<void>","level: IsolationLevel","extendWithFixtures","wrappedTest: T","fixtures: FixtureCreators<Transaction<Database>, Extended>"],"sources":["../src/kysely.ts"],"sourcesContent":["import type { Kysely, Transaction } from 'kysely';\nimport type { TestAPI } from 'vitest';\nimport { VitestKyselyTransactionIsolator } from './VitestKyselyTransactionIsolator';\nimport {\n  type DatabaseConnection,\n  type FixtureCreators,\n  IsolationLevel,\n  extendWithFixtures as baseExtendWithFixtures,\n} from './VitestTransactionIsolator';\n\n/**\n * Kysely-specific exports for test utilities.\n * Provides factories, migrators, and transaction isolators for Kysely ORM.\n */\n\nexport { KyselyFactory } from './KyselyFactory';\nexport { PostgresKyselyMigrator } from './PostgresKyselyMigrator';\nexport { VitestKyselyTransactionIsolator } from './VitestKyselyTransactionIsolator';\nexport { IsolationLevel } from './VitestTransactionIsolator';\nexport type {\n  DatabaseFixtures,\n  ExtendedDatabaseFixtures,\n  FixtureCreators,\n  TestWithExtendedFixtures,\n} from './VitestTransactionIsolator';\n\n// Re-export faker and FakerFactory for type portability in declaration files\nexport { faker, type FakerFactory } from './faker';\n\n/**\n * Creates a wrapped Vitest test API with automatic transaction rollback for Kysely.\n * Each test runs in an isolated database transaction that is rolled back after completion.\n * This ensures tests don't affect each other's data and run faster than truncating tables.\n *\n * @template Database - The database schema type\n * @param api - The Vitest test API (usually `test` from vitest)\n * @param db - The Kysely database instance\n * @param setup - Optional setup function to run before each test in the transaction\n * @param level - Transaction isolation level (defaults to REPEATABLE_READ)\n * @returns A wrapped test API that provides transaction isolation\n *\n * @example\n * ```typescript\n * import { test } from 'vitest';\n * import { wrapVitestKyselyTransaction } from '@geekmidas/testkit/kysely';\n * import { db } from './database';\n *\n * // Create isolated test with automatic rollback\n * const isolatedTest = wrapVitestKyselyTransaction(test, db);\n *\n * // Use in tests - each test gets its own transaction\n * isolatedTest('should create user', async ({ trx }) => {\n *   const user = await trx\n *     .insertInto('users')\n *     .values({ name: 'Test User', email: 'test@example.com' })\n *     .returningAll()\n *     .executeTakeFirst();\n *\n *   expect(user).toBeDefined();\n *   // User is automatically rolled back after test\n * });\n *\n * // With setup function for common test data\n * const testWithSetup = wrapVitestKyselyTransaction(\n *   test,\n *   db,\n *   async (trx) => {\n *     // Create common test data\n *     await trx.insertInto('settings')\n *       .values({ key: 'test_mode', value: 'true' })\n *       .execute();\n *   }\n * );\n *\n * testWithSetup('should have test settings', async ({ trx }) => {\n *   const setting = await trx\n *     .selectFrom('settings')\n *     .where('key', '=', 'test_mode')\n *     .selectAll()\n *     .executeTakeFirst();\n *\n *   expect(setting?.value).toBe('true');\n * });\n * ```\n */\nexport function wrapVitestKyselyTransaction<Database>(\n  api: TestAPI,\n  connection: DatabaseConnection<Kysely<Database>>,\n  setup?: (trx: Transaction<Database>) => Promise<void>,\n  level: IsolationLevel = IsolationLevel.REPEATABLE_READ,\n) {\n  const wrapper = new VitestKyselyTransactionIsolator<Database>(api);\n\n  return wrapper.wrapVitestWithTransaction(connection, setup, level);\n}\n\n/**\n * Extends a Kysely transaction-wrapped test with additional fixtures.\n * Each fixture receives the transaction and can create dependencies like factories or repositories.\n *\n * @template Database - The database schema type\n * @template Extended - The type of additional fixtures to provide\n * @param wrappedTest - The base wrapped test from wrapVitestKyselyTransaction\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 { test } from 'vitest';\n * import { wrapVitestKyselyTransaction, extendWithFixtures, KyselyFactory } from '@geekmidas/testkit/kysely';\n *\n * // Define your builders\n * const builders = {\n *   user: KyselyFactory.createBuilder<DB, 'users'>('users', ({ faker }) => ({\n *     name: faker.person.fullName(),\n *     email: faker.internet.email(),\n *   })),\n * };\n *\n * // Create base wrapped test\n * const baseTest = wrapVitestKyselyTransaction<DB>(test, db, createTestTables);\n *\n * // Extend with fixtures - each fixture receives the transaction\n * const it = extendWithFixtures<DB, { factory: KyselyFactory<DB, typeof builders, {}> }>(\n *   baseTest,\n *   {\n *     factory: (trx) => new KyselyFactory(builders, {}, trx),\n *   }\n * );\n *\n * // Use in tests - both trx and factory are available\n * it('should create user with factory', async ({ trx, factory }) => {\n *   const user = await factory.insert('user', { name: 'Test User' });\n *   expect(user.id).toBeDefined();\n *\n *   // Verify in database\n *   const found = await trx\n *     .selectFrom('users')\n *     .where('id', '=', user.id)\n *     .selectAll()\n *     .executeTakeFirst();\n *   expect(found?.name).toBe('Test User');\n * });\n * ```\n */\nexport function extendWithFixtures<\n  Database,\n  Extended extends Record<string, unknown>,\n  T extends ReturnType<TestAPI['extend']> = ReturnType<TestAPI['extend']>,\n>(wrappedTest: T, fixtures: FixtureCreators<Transaction<Database>, Extended>) {\n  return baseExtendWithFixtures<Transaction<Database>, Extended, T>(\n    wrappedTest,\n    fixtures,\n  );\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAqFA,SAAgB,4BACdA,KACAC,YACAC,OACAC,QAAwB,eAAe,iBACvC;CACA,MAAM,UAAU,IAAI,gCAA0C;AAE9D,QAAO,QAAQ,0BAA0B,YAAY,OAAO,MAAM;AACnE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAmDD,SAAgBC,qBAIdC,aAAgBC,UAA4D;AAC5E,QAAO,mBACL,aACA,SACD;AACF"}

package/dist/objection.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"objection.cjs","names":["api: TestAPI","conn: DatabaseConnection<Knex>","setup?: (trx: Knex.Transaction) => Promise<void>","level: IsolationLevel","IsolationLevel","VitestObjectionTransactionIsolator","extendWithFixtures","wrappedTest: T","fixtures: FixtureCreators<Knex.Transaction, Extended>"],"sources":["../src/objection.ts"],"sourcesContent":["import type { Knex } from 'knex';\nimport type { TestAPI } from 'vitest';\nimport { VitestObjectionTransactionIsolator } from './VitestObjectionTransactionIsolator';\nimport {\n  type DatabaseConnection,\n  type FixtureCreators,\n  IsolationLevel,\n  extendWithFixtures as baseExtendWithFixtures,\n} from './VitestTransactionIsolator';\n\n/**\n * Objection.js-specific exports for test utilities.\n * Provides factory implementation for creating test data with Objection.js ORM\n * and transaction isolation for test suites.\n */\n\nexport { ObjectionFactory } from './ObjectionFactory';\nexport { VitestObjectionTransactionIsolator } from './VitestObjectionTransactionIsolator';\nexport { IsolationLevel } from './VitestTransactionIsolator';\nexport { PostgresObjectionMigrator } from './PostgresObjectionMigrator';\nexport type { FixtureCreators } from './VitestTransactionIsolator';\n\n// Re-export faker and FakerFactory for type portability in declaration files\nexport { faker, type FakerFactory } from './faker';\n\n/**\n * Creates a wrapped Vitest test API with automatic transaction rollback for Objection.js.\n * Each test runs in an isolated database transaction that is rolled back after completion.\n * This ensures tests don't affect each other's data and run faster than truncating tables.\n *\n * @param api - The Vitest test API (usually `test` from vitest)\n * @param conn - The Knex database connection instance\n * @param setup - Optional setup function to run before each test in the transaction\n * @param level - Transaction isolation level (defaults to REPEATABLE_READ)\n * @returns A wrapped test API that provides transaction isolation\n *\n * @example\n * ```typescript\n * import { test } from 'vitest';\n * import { wrapVitestObjectionTransaction } from '@geekmidas/testkit/objection';\n * import { knex } from './database';\n * import { User, Post } from './models';\n *\n * // Create isolated test with automatic rollback\n * const isolatedTest = wrapVitestObjectionTransaction(test, knex);\n *\n * // Use in tests - each test gets its own transaction\n * isolatedTest('should create user', async ({ trx }) => {\n *   const user = await User.query(trx)\n *     .insert({ name: 'Test User', email: 'test@example.com' });\n *\n *   expect(user).toBeDefined();\n *   // User is automatically rolled back after test\n * });\n *\n * // With setup function for common test data\n * const testWithSetup = wrapVitestObjectionTransaction(\n *   test,\n *   knex,\n *   async (trx) => {\n *     // Create common test data\n *     await knex('settings')\n *       .transacting(trx)\n *       .insert({ key: 'test_mode', value: 'true' });\n *   }\n * );\n *\n * testWithSetup('should have test settings', async ({ trx }) => {\n *   const setting = await knex('settings')\n *     .transacting(trx)\n *     .where('key', 'test_mode')\n *     .first();\n *\n *   expect(setting?.value).toBe('true');\n * });\n *\n * // Example with factory and transaction\n * const isolatedTest = wrapVitestObjectionTransaction(test, knex);\n * const factory = new ObjectionFactory(builders, seeds, knex);\n *\n * isolatedTest('creates related data', async ({ trx }) => {\n *   // Factory can use the transaction\n *   const user = await User.query(trx).insert({ name: 'Author' });\n *   const posts = await Post.query(trx).insert([\n *     { title: 'Post 1', userId: user.id },\n *     { title: 'Post 2', userId: user.id }\n *   ]);\n *\n *   const userWithPosts = await User.query(trx)\n *     .findById(user.id)\n *     .withGraphFetched('posts');\n *\n *   expect(userWithPosts.posts).toHaveLength(2);\n * });\n * ```\n */\nexport function wrapVitestObjectionTransaction(\n  api: TestAPI,\n  conn: DatabaseConnection<Knex>,\n  setup?: (trx: Knex.Transaction) => Promise<void>,\n  level: IsolationLevel = IsolationLevel.REPEATABLE_READ,\n) {\n  const wrapper = new VitestObjectionTransactionIsolator(api);\n\n  return wrapper.wrapVitestWithTransaction(conn, setup, level);\n}\n\n/**\n * Extends an Objection.js transaction-wrapped test with additional fixtures.\n * Each fixture receives the transaction and can create dependencies like factories or repositories.\n *\n * @template Extended - The type of additional fixtures to provide\n * @param wrappedTest - The base wrapped test from wrapVitestObjectionTransaction\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 { test } from 'vitest';\n * import { wrapVitestObjectionTransaction, extendWithFixtures, ObjectionFactory } from '@geekmidas/testkit/objection';\n * import { User } from './models';\n *\n * // Define your builders\n * const builders = {\n *   user: ObjectionFactory.createBuilder(User, ({ faker }) => ({\n *     name: faker.person.fullName(),\n *     email: faker.internet.email(),\n *   })),\n * };\n *\n * // Create base wrapped test\n * const baseTest = wrapVitestObjectionTransaction(test, knex, createTestTables);\n *\n * // Extend with fixtures - each fixture receives the transaction\n * const it = extendWithFixtures<{ factory: ObjectionFactory<typeof builders, {}> }>(\n *   baseTest,\n *   {\n *     factory: (trx) => new ObjectionFactory(builders, {}, trx),\n *   }\n * );\n *\n * // Use in tests - both trx and factory are available\n * it('should create user with factory', async ({ trx, factory }) => {\n *   const user = await factory.insert('user', { name: 'Test User' });\n *   expect(user.id).toBeDefined();\n *\n *   // Verify in database\n *   const found = await User.query(trx).findById(user.id);\n *   expect(found?.name).toBe('Test User');\n * });\n * ```\n */\nexport function extendWithFixtures<\n  Extended extends Record<string, unknown>,\n  T extends ReturnType<TestAPI['extend']> = ReturnType<TestAPI['extend']>,\n>(wrappedTest: T, fixtures: FixtureCreators<Knex.Transaction, Extended>) {\n  return baseExtendWithFixtures<Knex.Transaction, Extended, T>(\n    wrappedTest,\n    fixtures,\n  );\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgGA,SAAgB,+BACdA,KACAC,MACAC,OACAC,QAAwBC,iDAAe,iBACvC;CACA,MAAM,UAAU,IAAIC,8EAAmC;AAEvD,QAAO,QAAQ,0BAA0B,MAAM,OAAO,MAAM;AAC7D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+CD,SAAgBC,qBAGdC,aAAgBC,UAAuD;AACvE,QAAO,qDACL,aACA,SACD;AACF"}
+{"version":3,"file":"objection.cjs","names":["api: TestAPI","conn: DatabaseConnection<Knex>","setup?: (trx: Knex.Transaction) => Promise<void>","level: IsolationLevel","IsolationLevel","VitestObjectionTransactionIsolator","extendWithFixtures","wrappedTest: T","fixtures: FixtureCreators<Knex.Transaction, Extended>"],"sources":["../src/objection.ts"],"sourcesContent":["import type { Knex } from 'knex';\nimport type { TestAPI } from 'vitest';\nimport { VitestObjectionTransactionIsolator } from './VitestObjectionTransactionIsolator';\nimport {\n  type DatabaseConnection,\n  type FixtureCreators,\n  IsolationLevel,\n  extendWithFixtures as baseExtendWithFixtures,\n} from './VitestTransactionIsolator';\n\n/**\n * Objection.js-specific exports for test utilities.\n * Provides factory implementation for creating test data with Objection.js ORM\n * and transaction isolation for test suites.\n */\n\nexport { ObjectionFactory } from './ObjectionFactory';\nexport { VitestObjectionTransactionIsolator } from './VitestObjectionTransactionIsolator';\nexport { IsolationLevel } from './VitestTransactionIsolator';\nexport { PostgresObjectionMigrator } from './PostgresObjectionMigrator';\nexport type {\n  DatabaseFixtures,\n  ExtendedDatabaseFixtures,\n  FixtureCreators,\n  TestWithExtendedFixtures,\n} from './VitestTransactionIsolator';\n\n// Re-export faker and FakerFactory for type portability in declaration files\nexport { faker, type FakerFactory } from './faker';\n\n/**\n * Creates a wrapped Vitest test API with automatic transaction rollback for Objection.js.\n * Each test runs in an isolated database transaction that is rolled back after completion.\n * This ensures tests don't affect each other's data and run faster than truncating tables.\n *\n * @param api - The Vitest test API (usually `test` from vitest)\n * @param conn - The Knex database connection instance\n * @param setup - Optional setup function to run before each test in the transaction\n * @param level - Transaction isolation level (defaults to REPEATABLE_READ)\n * @returns A wrapped test API that provides transaction isolation\n *\n * @example\n * ```typescript\n * import { test } from 'vitest';\n * import { wrapVitestObjectionTransaction } from '@geekmidas/testkit/objection';\n * import { knex } from './database';\n * import { User, Post } from './models';\n *\n * // Create isolated test with automatic rollback\n * const isolatedTest = wrapVitestObjectionTransaction(test, knex);\n *\n * // Use in tests - each test gets its own transaction\n * isolatedTest('should create user', async ({ trx }) => {\n *   const user = await User.query(trx)\n *     .insert({ name: 'Test User', email: 'test@example.com' });\n *\n *   expect(user).toBeDefined();\n *   // User is automatically rolled back after test\n * });\n *\n * // With setup function for common test data\n * const testWithSetup = wrapVitestObjectionTransaction(\n *   test,\n *   knex,\n *   async (trx) => {\n *     // Create common test data\n *     await knex('settings')\n *       .transacting(trx)\n *       .insert({ key: 'test_mode', value: 'true' });\n *   }\n * );\n *\n * testWithSetup('should have test settings', async ({ trx }) => {\n *   const setting = await knex('settings')\n *     .transacting(trx)\n *     .where('key', 'test_mode')\n *     .first();\n *\n *   expect(setting?.value).toBe('true');\n * });\n *\n * // Example with factory and transaction\n * const isolatedTest = wrapVitestObjectionTransaction(test, knex);\n * const factory = new ObjectionFactory(builders, seeds, knex);\n *\n * isolatedTest('creates related data', async ({ trx }) => {\n *   // Factory can use the transaction\n *   const user = await User.query(trx).insert({ name: 'Author' });\n *   const posts = await Post.query(trx).insert([\n *     { title: 'Post 1', userId: user.id },\n *     { title: 'Post 2', userId: user.id }\n *   ]);\n *\n *   const userWithPosts = await User.query(trx)\n *     .findById(user.id)\n *     .withGraphFetched('posts');\n *\n *   expect(userWithPosts.posts).toHaveLength(2);\n * });\n * ```\n */\nexport function wrapVitestObjectionTransaction(\n  api: TestAPI,\n  conn: DatabaseConnection<Knex>,\n  setup?: (trx: Knex.Transaction) => Promise<void>,\n  level: IsolationLevel = IsolationLevel.REPEATABLE_READ,\n) {\n  const wrapper = new VitestObjectionTransactionIsolator(api);\n\n  return wrapper.wrapVitestWithTransaction(conn, setup, level);\n}\n\n/**\n * Extends an Objection.js transaction-wrapped test with additional fixtures.\n * Each fixture receives the transaction and can create dependencies like factories or repositories.\n *\n * @template Extended - The type of additional fixtures to provide\n * @param wrappedTest - The base wrapped test from wrapVitestObjectionTransaction\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 { test } from 'vitest';\n * import { wrapVitestObjectionTransaction, extendWithFixtures, ObjectionFactory } from '@geekmidas/testkit/objection';\n * import { User } from './models';\n *\n * // Define your builders\n * const builders = {\n *   user: ObjectionFactory.createBuilder(User, ({ faker }) => ({\n *     name: faker.person.fullName(),\n *     email: faker.internet.email(),\n *   })),\n * };\n *\n * // Create base wrapped test\n * const baseTest = wrapVitestObjectionTransaction(test, knex, createTestTables);\n *\n * // Extend with fixtures - each fixture receives the transaction\n * const it = extendWithFixtures<{ factory: ObjectionFactory<typeof builders, {}> }>(\n *   baseTest,\n *   {\n *     factory: (trx) => new ObjectionFactory(builders, {}, trx),\n *   }\n * );\n *\n * // Use in tests - both trx and factory are available\n * it('should create user with factory', async ({ trx, factory }) => {\n *   const user = await factory.insert('user', { name: 'Test User' });\n *   expect(user.id).toBeDefined();\n *\n *   // Verify in database\n *   const found = await User.query(trx).findById(user.id);\n *   expect(found?.name).toBe('Test User');\n * });\n * ```\n */\nexport function extendWithFixtures<\n  Extended extends Record<string, unknown>,\n  T extends ReturnType<TestAPI['extend']> = ReturnType<TestAPI['extend']>,\n>(wrappedTest: T, fixtures: FixtureCreators<Knex.Transaction, Extended>) {\n  return baseExtendWithFixtures<Knex.Transaction, Extended, T>(\n    wrappedTest,\n    fixtures,\n  );\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAqGA,SAAgB,+BACdA,KACAC,MACAC,OACAC,QAAwBC,iDAAe,iBACvC;CACA,MAAM,UAAU,IAAIC,8EAAmC;AAEvD,QAAO,QAAQ,0BAA0B,MAAM,OAAO,MAAM;AAC7D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+CD,SAAgBC,qBAGdC,aAAgBC,UAAuD;AACvE,QAAO,qDACL,aACA,SACD;AACF"}

package/dist/objection.d.cts

@@ -1,10 +1,10 @@
-import { FakerFactory, faker } from "./faker-Cg76aFNO.cjs";
-import "./Factory-BZ8uMoXl.cjs";
-import { ObjectionFactory } from "./ObjectionFactory-CeSIN3kZ.cjs";
+import { FakerFactory, faker } from "./faker-BSH1EMtg.cjs";
+import "./Factory-pNV7ZQ7-.cjs";
+import { ObjectionFactory } from "./ObjectionFactory-BwpN4gMX.cjs";
 import "./PostgresMigrator-D5UkK1_K.cjs";
 import { PostgresObjectionMigrator } from "./PostgresObjectionMigrator-CZHHcCOv.cjs";
-import { DatabaseConnection, DatabaseFixtures, FixtureCreators, IsolationLevel } from "./VitestTransactionIsolator-CyG_i_Nj.cjs";
-import { VitestObjectionTransactionIsolator } from "./VitestObjectionTransactionIsolator-COVDlpEo.cjs";
+import { DatabaseConnection, DatabaseFixtures, ExtendedDatabaseFixtures, FixtureCreators, IsolationLevel, TestWithExtendedFixtures } from "./VitestTransactionIsolator-DfA80g2M.cjs";
+import { VitestObjectionTransactionIsolator } from "./VitestObjectionTransactionIsolator-CD2ucJpH.cjs";
 import { Knex } from "knex";
 import { TestAPI } from "vitest";
 
@@ -129,10 +129,7 @@ declare function wrapVitestObjectionTransaction(api: TestAPI, conn: DatabaseConn
  * });
  * ```
  */
-declare function extendWithFixtures<Extended extends Record<string, unknown>, T extends ReturnType<TestAPI['extend']> = ReturnType<TestAPI['extend']>>(wrappedTest: T, fixtures: FixtureCreators<Knex.Transaction, Extended>): T & {
-  <C extends object>(name: string, fn: (context: DatabaseFixtures<Knex.Transaction<any, any[]>, object> & Extended & C) => Promise<void>): void;
-  <C extends object>(name: string, options: object, fn: (context: DatabaseFixtures<Knex.Transaction<any, any[]>, object> & Extended & C) => Promise<void>): void;
-};
+declare function extendWithFixtures<Extended extends Record<string, unknown>, T extends ReturnType<TestAPI['extend']> = ReturnType<TestAPI['extend']>>(wrappedTest: T, fixtures: FixtureCreators<Knex.Transaction, Extended>): TestWithExtendedFixtures<Knex.Transaction<any, any[]>, Extended, T>;
 //#endregion
-export { FakerFactory, FixtureCreators, IsolationLevel, ObjectionFactory, PostgresObjectionMigrator, VitestObjectionTransactionIsolator, extendWithFixtures, faker, wrapVitestObjectionTransaction };
+export { DatabaseFixtures, ExtendedDatabaseFixtures, FakerFactory, FixtureCreators, IsolationLevel, ObjectionFactory, PostgresObjectionMigrator, TestWithExtendedFixtures, VitestObjectionTransactionIsolator, extendWithFixtures, faker, wrapVitestObjectionTransaction };
 //# sourceMappingURL=objection.d.cts.map

package/dist/objection.d.mts

@@ -1,10 +1,10 @@
-import { FakerFactory, faker } from "./faker-DHh7xs4u.mjs";
-import "./Factory-Cmr3s3-s.mjs";
-import { ObjectionFactory } from "./ObjectionFactory-BagGjikT.mjs";
+import { FakerFactory, faker } from "./faker-D9gz7KjY.mjs";
+import "./Factory-DE3hE0WO.mjs";
+import { ObjectionFactory } from "./ObjectionFactory-BlBicEia.mjs";
 import "./PostgresMigrator-DQaRxoaY.mjs";
 import { PostgresObjectionMigrator } from "./PostgresObjectionMigrator-D_hCcrQu.mjs";
-import { DatabaseConnection, DatabaseFixtures, FixtureCreators, IsolationLevel } from "./VitestTransactionIsolator-DWDbnITQ.mjs";
-import { VitestObjectionTransactionIsolator } from "./VitestObjectionTransactionIsolator-lZUSz1w0.mjs";
+import { DatabaseConnection, DatabaseFixtures, ExtendedDatabaseFixtures, FixtureCreators, IsolationLevel, TestWithExtendedFixtures } from "./VitestTransactionIsolator-DLdQlfZ5.mjs";
+import { VitestObjectionTransactionIsolator } from "./VitestObjectionTransactionIsolator-DhQ8XGva.mjs";
 import { TestAPI } from "vitest";
 import { Knex } from "knex";
 
@@ -129,10 +129,7 @@ declare function wrapVitestObjectionTransaction(api: TestAPI, conn: DatabaseConn
  * });
  * ```
  */
-declare function extendWithFixtures<Extended extends Record<string, unknown>, T extends ReturnType<TestAPI['extend']> = ReturnType<TestAPI['extend']>>(wrappedTest: T, fixtures: FixtureCreators<Knex.Transaction, Extended>): T & {
-  <C extends object>(name: string, fn: (context: DatabaseFixtures<Knex.Transaction<any, any[]>, object> & Extended & C) => Promise<void>): void;
-  <C extends object>(name: string, options: object, fn: (context: DatabaseFixtures<Knex.Transaction<any, any[]>, object> & Extended & C) => Promise<void>): void;
-};
+declare function extendWithFixtures<Extended extends Record<string, unknown>, T extends ReturnType<TestAPI['extend']> = ReturnType<TestAPI['extend']>>(wrappedTest: T, fixtures: FixtureCreators<Knex.Transaction, Extended>): TestWithExtendedFixtures<Knex.Transaction<any, any[]>, Extended, T>;
 //#endregion
-export { FakerFactory, FixtureCreators, IsolationLevel, ObjectionFactory, PostgresObjectionMigrator, VitestObjectionTransactionIsolator, extendWithFixtures, faker, wrapVitestObjectionTransaction };
+export { DatabaseFixtures, ExtendedDatabaseFixtures, FakerFactory, FixtureCreators, IsolationLevel, ObjectionFactory, PostgresObjectionMigrator, TestWithExtendedFixtures, VitestObjectionTransactionIsolator, extendWithFixtures, faker, wrapVitestObjectionTransaction };
 //# sourceMappingURL=objection.d.mts.map

package/dist/objection.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"objection.mjs","names":["api: TestAPI","conn: DatabaseConnection<Knex>","setup?: (trx: Knex.Transaction) => Promise<void>","level: IsolationLevel","extendWithFixtures","wrappedTest: T","fixtures: FixtureCreators<Knex.Transaction, Extended>"],"sources":["../src/objection.ts"],"sourcesContent":["import type { Knex } from 'knex';\nimport type { TestAPI } from 'vitest';\nimport { VitestObjectionTransactionIsolator } from './VitestObjectionTransactionIsolator';\nimport {\n  type DatabaseConnection,\n  type FixtureCreators,\n  IsolationLevel,\n  extendWithFixtures as baseExtendWithFixtures,\n} from './VitestTransactionIsolator';\n\n/**\n * Objection.js-specific exports for test utilities.\n * Provides factory implementation for creating test data with Objection.js ORM\n * and transaction isolation for test suites.\n */\n\nexport { ObjectionFactory } from './ObjectionFactory';\nexport { VitestObjectionTransactionIsolator } from './VitestObjectionTransactionIsolator';\nexport { IsolationLevel } from './VitestTransactionIsolator';\nexport { PostgresObjectionMigrator } from './PostgresObjectionMigrator';\nexport type { FixtureCreators } from './VitestTransactionIsolator';\n\n// Re-export faker and FakerFactory for type portability in declaration files\nexport { faker, type FakerFactory } from './faker';\n\n/**\n * Creates a wrapped Vitest test API with automatic transaction rollback for Objection.js.\n * Each test runs in an isolated database transaction that is rolled back after completion.\n * This ensures tests don't affect each other's data and run faster than truncating tables.\n *\n * @param api - The Vitest test API (usually `test` from vitest)\n * @param conn - The Knex database connection instance\n * @param setup - Optional setup function to run before each test in the transaction\n * @param level - Transaction isolation level (defaults to REPEATABLE_READ)\n * @returns A wrapped test API that provides transaction isolation\n *\n * @example\n * ```typescript\n * import { test } from 'vitest';\n * import { wrapVitestObjectionTransaction } from '@geekmidas/testkit/objection';\n * import { knex } from './database';\n * import { User, Post } from './models';\n *\n * // Create isolated test with automatic rollback\n * const isolatedTest = wrapVitestObjectionTransaction(test, knex);\n *\n * // Use in tests - each test gets its own transaction\n * isolatedTest('should create user', async ({ trx }) => {\n *   const user = await User.query(trx)\n *     .insert({ name: 'Test User', email: 'test@example.com' });\n *\n *   expect(user).toBeDefined();\n *   // User is automatically rolled back after test\n * });\n *\n * // With setup function for common test data\n * const testWithSetup = wrapVitestObjectionTransaction(\n *   test,\n *   knex,\n *   async (trx) => {\n *     // Create common test data\n *     await knex('settings')\n *       .transacting(trx)\n *       .insert({ key: 'test_mode', value: 'true' });\n *   }\n * );\n *\n * testWithSetup('should have test settings', async ({ trx }) => {\n *   const setting = await knex('settings')\n *     .transacting(trx)\n *     .where('key', 'test_mode')\n *     .first();\n *\n *   expect(setting?.value).toBe('true');\n * });\n *\n * // Example with factory and transaction\n * const isolatedTest = wrapVitestObjectionTransaction(test, knex);\n * const factory = new ObjectionFactory(builders, seeds, knex);\n *\n * isolatedTest('creates related data', async ({ trx }) => {\n *   // Factory can use the transaction\n *   const user = await User.query(trx).insert({ name: 'Author' });\n *   const posts = await Post.query(trx).insert([\n *     { title: 'Post 1', userId: user.id },\n *     { title: 'Post 2', userId: user.id }\n *   ]);\n *\n *   const userWithPosts = await User.query(trx)\n *     .findById(user.id)\n *     .withGraphFetched('posts');\n *\n *   expect(userWithPosts.posts).toHaveLength(2);\n * });\n * ```\n */\nexport function wrapVitestObjectionTransaction(\n  api: TestAPI,\n  conn: DatabaseConnection<Knex>,\n  setup?: (trx: Knex.Transaction) => Promise<void>,\n  level: IsolationLevel = IsolationLevel.REPEATABLE_READ,\n) {\n  const wrapper = new VitestObjectionTransactionIsolator(api);\n\n  return wrapper.wrapVitestWithTransaction(conn, setup, level);\n}\n\n/**\n * Extends an Objection.js transaction-wrapped test with additional fixtures.\n * Each fixture receives the transaction and can create dependencies like factories or repositories.\n *\n * @template Extended - The type of additional fixtures to provide\n * @param wrappedTest - The base wrapped test from wrapVitestObjectionTransaction\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 { test } from 'vitest';\n * import { wrapVitestObjectionTransaction, extendWithFixtures, ObjectionFactory } from '@geekmidas/testkit/objection';\n * import { User } from './models';\n *\n * // Define your builders\n * const builders = {\n *   user: ObjectionFactory.createBuilder(User, ({ faker }) => ({\n *     name: faker.person.fullName(),\n *     email: faker.internet.email(),\n *   })),\n * };\n *\n * // Create base wrapped test\n * const baseTest = wrapVitestObjectionTransaction(test, knex, createTestTables);\n *\n * // Extend with fixtures - each fixture receives the transaction\n * const it = extendWithFixtures<{ factory: ObjectionFactory<typeof builders, {}> }>(\n *   baseTest,\n *   {\n *     factory: (trx) => new ObjectionFactory(builders, {}, trx),\n *   }\n * );\n *\n * // Use in tests - both trx and factory are available\n * it('should create user with factory', async ({ trx, factory }) => {\n *   const user = await factory.insert('user', { name: 'Test User' });\n *   expect(user.id).toBeDefined();\n *\n *   // Verify in database\n *   const found = await User.query(trx).findById(user.id);\n *   expect(found?.name).toBe('Test User');\n * });\n * ```\n */\nexport function extendWithFixtures<\n  Extended extends Record<string, unknown>,\n  T extends ReturnType<TestAPI['extend']> = ReturnType<TestAPI['extend']>,\n>(wrappedTest: T, fixtures: FixtureCreators<Knex.Transaction, Extended>) {\n  return baseExtendWithFixtures<Knex.Transaction, Extended, T>(\n    wrappedTest,\n    fixtures,\n  );\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgGA,SAAgB,+BACdA,KACAC,MACAC,OACAC,QAAwB,eAAe,iBACvC;CACA,MAAM,UAAU,IAAI,mCAAmC;AAEvD,QAAO,QAAQ,0BAA0B,MAAM,OAAO,MAAM;AAC7D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+CD,SAAgBC,qBAGdC,aAAgBC,UAAuD;AACvE,QAAO,mBACL,aACA,SACD;AACF"}
+{"version":3,"file":"objection.mjs","names":["api: TestAPI","conn: DatabaseConnection<Knex>","setup?: (trx: Knex.Transaction) => Promise<void>","level: IsolationLevel","extendWithFixtures","wrappedTest: T","fixtures: FixtureCreators<Knex.Transaction, Extended>"],"sources":["../src/objection.ts"],"sourcesContent":["import type { Knex } from 'knex';\nimport type { TestAPI } from 'vitest';\nimport { VitestObjectionTransactionIsolator } from './VitestObjectionTransactionIsolator';\nimport {\n  type DatabaseConnection,\n  type FixtureCreators,\n  IsolationLevel,\n  extendWithFixtures as baseExtendWithFixtures,\n} from './VitestTransactionIsolator';\n\n/**\n * Objection.js-specific exports for test utilities.\n * Provides factory implementation for creating test data with Objection.js ORM\n * and transaction isolation for test suites.\n */\n\nexport { ObjectionFactory } from './ObjectionFactory';\nexport { VitestObjectionTransactionIsolator } from './VitestObjectionTransactionIsolator';\nexport { IsolationLevel } from './VitestTransactionIsolator';\nexport { PostgresObjectionMigrator } from './PostgresObjectionMigrator';\nexport type {\n  DatabaseFixtures,\n  ExtendedDatabaseFixtures,\n  FixtureCreators,\n  TestWithExtendedFixtures,\n} from './VitestTransactionIsolator';\n\n// Re-export faker and FakerFactory for type portability in declaration files\nexport { faker, type FakerFactory } from './faker';\n\n/**\n * Creates a wrapped Vitest test API with automatic transaction rollback for Objection.js.\n * Each test runs in an isolated database transaction that is rolled back after completion.\n * This ensures tests don't affect each other's data and run faster than truncating tables.\n *\n * @param api - The Vitest test API (usually `test` from vitest)\n * @param conn - The Knex database connection instance\n * @param setup - Optional setup function to run before each test in the transaction\n * @param level - Transaction isolation level (defaults to REPEATABLE_READ)\n * @returns A wrapped test API that provides transaction isolation\n *\n * @example\n * ```typescript\n * import { test } from 'vitest';\n * import { wrapVitestObjectionTransaction } from '@geekmidas/testkit/objection';\n * import { knex } from './database';\n * import { User, Post } from './models';\n *\n * // Create isolated test with automatic rollback\n * const isolatedTest = wrapVitestObjectionTransaction(test, knex);\n *\n * // Use in tests - each test gets its own transaction\n * isolatedTest('should create user', async ({ trx }) => {\n *   const user = await User.query(trx)\n *     .insert({ name: 'Test User', email: 'test@example.com' });\n *\n *   expect(user).toBeDefined();\n *   // User is automatically rolled back after test\n * });\n *\n * // With setup function for common test data\n * const testWithSetup = wrapVitestObjectionTransaction(\n *   test,\n *   knex,\n *   async (trx) => {\n *     // Create common test data\n *     await knex('settings')\n *       .transacting(trx)\n *       .insert({ key: 'test_mode', value: 'true' });\n *   }\n * );\n *\n * testWithSetup('should have test settings', async ({ trx }) => {\n *   const setting = await knex('settings')\n *     .transacting(trx)\n *     .where('key', 'test_mode')\n *     .first();\n *\n *   expect(setting?.value).toBe('true');\n * });\n *\n * // Example with factory and transaction\n * const isolatedTest = wrapVitestObjectionTransaction(test, knex);\n * const factory = new ObjectionFactory(builders, seeds, knex);\n *\n * isolatedTest('creates related data', async ({ trx }) => {\n *   // Factory can use the transaction\n *   const user = await User.query(trx).insert({ name: 'Author' });\n *   const posts = await Post.query(trx).insert([\n *     { title: 'Post 1', userId: user.id },\n *     { title: 'Post 2', userId: user.id }\n *   ]);\n *\n *   const userWithPosts = await User.query(trx)\n *     .findById(user.id)\n *     .withGraphFetched('posts');\n *\n *   expect(userWithPosts.posts).toHaveLength(2);\n * });\n * ```\n */\nexport function wrapVitestObjectionTransaction(\n  api: TestAPI,\n  conn: DatabaseConnection<Knex>,\n  setup?: (trx: Knex.Transaction) => Promise<void>,\n  level: IsolationLevel = IsolationLevel.REPEATABLE_READ,\n) {\n  const wrapper = new VitestObjectionTransactionIsolator(api);\n\n  return wrapper.wrapVitestWithTransaction(conn, setup, level);\n}\n\n/**\n * Extends an Objection.js transaction-wrapped test with additional fixtures.\n * Each fixture receives the transaction and can create dependencies like factories or repositories.\n *\n * @template Extended - The type of additional fixtures to provide\n * @param wrappedTest - The base wrapped test from wrapVitestObjectionTransaction\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 { test } from 'vitest';\n * import { wrapVitestObjectionTransaction, extendWithFixtures, ObjectionFactory } from '@geekmidas/testkit/objection';\n * import { User } from './models';\n *\n * // Define your builders\n * const builders = {\n *   user: ObjectionFactory.createBuilder(User, ({ faker }) => ({\n *     name: faker.person.fullName(),\n *     email: faker.internet.email(),\n *   })),\n * };\n *\n * // Create base wrapped test\n * const baseTest = wrapVitestObjectionTransaction(test, knex, createTestTables);\n *\n * // Extend with fixtures - each fixture receives the transaction\n * const it = extendWithFixtures<{ factory: ObjectionFactory<typeof builders, {}> }>(\n *   baseTest,\n *   {\n *     factory: (trx) => new ObjectionFactory(builders, {}, trx),\n *   }\n * );\n *\n * // Use in tests - both trx and factory are available\n * it('should create user with factory', async ({ trx, factory }) => {\n *   const user = await factory.insert('user', { name: 'Test User' });\n *   expect(user.id).toBeDefined();\n *\n *   // Verify in database\n *   const found = await User.query(trx).findById(user.id);\n *   expect(found?.name).toBe('Test User');\n * });\n * ```\n */\nexport function extendWithFixtures<\n  Extended extends Record<string, unknown>,\n  T extends ReturnType<TestAPI['extend']> = ReturnType<TestAPI['extend']>,\n>(wrappedTest: T, fixtures: FixtureCreators<Knex.Transaction, Extended>) {\n  return baseExtendWithFixtures<Knex.Transaction, Extended, T>(\n    wrappedTest,\n    fixtures,\n  );\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAqGA,SAAgB,+BACdA,KACAC,MACAC,OACAC,QAAwB,eAAe,iBACvC;CACA,MAAM,UAAU,IAAI,mCAAmC;AAEvD,QAAO,QAAQ,0BAA0B,MAAM,OAAO,MAAM;AAC7D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+CD,SAAgBC,qBAGdC,aAAgBC,UAAuD;AACvE,QAAO,mBACL,aACA,SACD;AACF"}

package/dist/os/directory.d.cts

@@ -1,2 +1,2 @@
-import { DirectoryFixtures, itWithDir } from "../directory-DlkPEzL4.cjs";
+import { DirectoryFixtures, itWithDir } from "../directory-Mi7tdOuD.cjs";
 export { DirectoryFixtures, itWithDir };

package/dist/os/directory.d.mts

@@ -1,2 +1,2 @@
-import { DirectoryFixtures, itWithDir } from "../directory-BXavAeJZ.mjs";
+import { DirectoryFixtures, itWithDir } from "../directory-Q178x53k.mjs";
 export { DirectoryFixtures, itWithDir };

package/dist/os/index.d.cts

@@ -1,2 +1,2 @@
-import { itWithDir } from "../directory-DlkPEzL4.cjs";
+import { itWithDir } from "../directory-Mi7tdOuD.cjs";
 export { itWithDir };

package/dist/os/index.d.mts

@@ -1,2 +1,2 @@
-import { itWithDir } from "../directory-BXavAeJZ.mjs";
+import { itWithDir } from "../directory-Q178x53k.mjs";
 export { itWithDir };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@geekmidas/testkit",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "private": false,
   "type": "module",
   "exports": {

package/src/VitestTransactionIsolator.ts

@@ -208,6 +208,36 @@ export type FixtureCreators<
   ) => 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
+ */
+export 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.
@@ -246,21 +276,7 @@ export function extendWithFixtures<
 >(
   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;
-} {
+): TestWithExtendedFixtures<Transaction, Extended, T> {
   // Build fixture definitions for Vitest's extend API
   const fixtureDefinitions: Record<string, any> = {};
 

package/src/kysely.ts

@@ -17,7 +17,12 @@ 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,
+} from './VitestTransactionIsolator';
 
 // Re-export faker and FakerFactory for type portability in declaration files
 export { faker, type FakerFactory } from './faker';

package/src/objection.ts

@@ -18,7 +18,12 @@ 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,
+} from './VitestTransactionIsolator';
 
 // Re-export faker and FakerFactory for type portability in declaration files
 export { faker, type FakerFactory } from './faker';