@geekmidas/testkit 0.0.17 → 0.1.0

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

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

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

@@ -1,4 +1,4 @@
-import * as _faker_js_faker2 from "@faker-js/faker";
+import * as _faker_js_faker1 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_faker2.Faker & {
+declare const faker$1: Readonly<_faker_js_faker1.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-Br8MzXil.d.mts.map
+//# sourceMappingURL=faker-DHh7xs4u.d.mts.map

package/dist/faker.d.mts

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

package/dist/kysely.cjs

@@ -1,10 +1,10 @@
 require('./Factory-WMhTNZ9S.cjs');
-require('./faker-B14IEMIN.cjs');
-const require_KyselyFactory = require('./KyselyFactory-Cf0o2YxO.cjs');
+const require_faker = require('./faker-B14IEMIN.cjs');
+const require_KyselyFactory = require('./KyselyFactory-DaaCykWP.cjs');
 require('./PostgresMigrator-DFcNdCvD.cjs');
 const require_PostgresKyselyMigrator = require('./PostgresKyselyMigrator-CfytARcA.cjs');
-const require_VitestTransactionIsolator = require('./VitestTransactionIsolator-BQ5FpLtC.cjs');
-const require_VitestKyselyTransactionIsolator = require('./VitestKyselyTransactionIsolator-Cst3vFjb.cjs');
+const require_VitestTransactionIsolator = require('./VitestTransactionIsolator-BKIrj3Uy.cjs');
+const require_VitestKyselyTransactionIsolator = require('./VitestKyselyTransactionIsolator-DX_VPKS-.cjs');
 
 //#region src/kysely.ts
 /**
@@ -67,11 +67,65 @@ function wrapVitestKyselyTransaction(api, connection, setup, level = require_Vit
 	const wrapper = new require_VitestKyselyTransactionIsolator.VitestKyselyTransactionIsolator(api);
 	return wrapper.wrapVitestWithTransaction(connection, setup, level);
 }
+/**
+* Extends a Kysely transaction-wrapped test with additional fixtures.
+* Each fixture receives the transaction and can create dependencies like factories or repositories.
+*
+* @template Database - The database schema type
+* @template Extended - The type of additional fixtures to provide
+* @param wrappedTest - The base wrapped test from wrapVitestKyselyTransaction
+* @param fixtures - Object mapping fixture names to creator functions
+* @returns An extended test API with both trx and the additional fixtures
+*
+* @example
+* ```typescript
+* import { test } from 'vitest';
+* import { wrapVitestKyselyTransaction, extendWithFixtures, KyselyFactory } from '@geekmidas/testkit/kysely';
+*
+* // Define your builders
+* const builders = {
+*   user: KyselyFactory.createBuilder<DB, 'users'>('users', ({ faker }) => ({
+*     name: faker.person.fullName(),
+*     email: faker.internet.email(),
+*   })),
+* };
+*
+* // Create base wrapped test
+* const baseTest = wrapVitestKyselyTransaction<DB>(test, db, createTestTables);
+*
+* // Extend with fixtures - each fixture receives the transaction
+* const it = extendWithFixtures<DB, { factory: KyselyFactory<DB, typeof builders, {}> }>(
+*   baseTest,
+*   {
+*     factory: (trx) => new KyselyFactory(builders, {}, trx),
+*   }
+* );
+*
+* // Use in tests - both trx and factory are available
+* it('should create user with factory', async ({ trx, factory }) => {
+*   const user = await factory.insert('user', { name: 'Test User' });
+*   expect(user.id).toBeDefined();
+*
+*   // Verify in database
+*   const found = await trx
+*     .selectFrom('users')
+*     .where('id', '=', user.id)
+*     .selectAll()
+*     .executeTakeFirst();
+*   expect(found?.name).toBe('Test User');
+* });
+* ```
+*/
+function extendWithFixtures$1(wrappedTest, fixtures) {
+	return require_VitestTransactionIsolator.extendWithFixtures(wrappedTest, fixtures);
+}
 
 //#endregion
 exports.IsolationLevel = require_VitestTransactionIsolator.IsolationLevel;
 exports.KyselyFactory = require_KyselyFactory.KyselyFactory;
 exports.PostgresKyselyMigrator = require_PostgresKyselyMigrator.PostgresKyselyMigrator;
 exports.VitestKyselyTransactionIsolator = require_VitestKyselyTransactionIsolator.VitestKyselyTransactionIsolator;
+exports.extendWithFixtures = extendWithFixtures$1;
+exports.faker = require_faker.faker;
 exports.wrapVitestKyselyTransaction = wrapVitestKyselyTransaction;
 //# sourceMappingURL=kysely.cjs.map

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"],"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  IsolationLevel,\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';\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"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA0EA,SAAgB,4BACdA,KACAC,YACAC,OACAC,QAAwBC,iDAAe,iBACvC;CACA,MAAM,UAAU,IAAIC,wEAA0C;AAE9D,QAAO,QAAQ,0BAA0B,YAAY,OAAO,MAAM;AACnE"}
+{"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"}

package/dist/kysely.d.cts

@@ -1,10 +1,10 @@
-import "./faker-Cg76aFNO.cjs";
+import { FakerFactory, faker } from "./faker-Cg76aFNO.cjs";
 import "./Factory-BZ8uMoXl.cjs";
-import { KyselyFactory } from "./KyselyFactory-DRQ83r0o.cjs";
+import { KyselyFactory } from "./KyselyFactory-BFygzOlO.cjs";
 import "./PostgresMigrator-D5UkK1_K.cjs";
 import { PostgresKyselyMigrator } from "./PostgresKyselyMigrator-CQ3aUoy_.cjs";
-import { DatabaseConnection, IsolationLevel } from "./VitestTransactionIsolator-DdLNODZg.cjs";
-import { VitestKyselyTransactionIsolator } from "./VitestKyselyTransactionIsolator-DYUYVEh9.cjs";
+import { DatabaseConnection, DatabaseFixtures, FixtureCreators, IsolationLevel } from "./VitestTransactionIsolator-CyG_i_Nj.cjs";
+import { VitestKyselyTransactionIsolator } from "./VitestKyselyTransactionIsolator-4HOeLQ0d.cjs";
 import { Kysely, Transaction } from "kysely";
 import { TestAPI } from "vitest";
 
@@ -69,6 +69,59 @@ import { TestAPI } from "vitest";
 declare function wrapVitestKyselyTransaction<Database>(api: TestAPI, connection: DatabaseConnection<Kysely<Database>>, setup?: (trx: Transaction<Database>) => Promise<void>, level?: IsolationLevel): TestAPI<{
   trx: Transaction<Database>;
 }>;
+/**
+ * Extends a Kysely transaction-wrapped test with additional fixtures.
+ * Each fixture receives the transaction and can create dependencies like factories or repositories.
+ *
+ * @template Database - The database schema type
+ * @template Extended - The type of additional fixtures to provide
+ * @param wrappedTest - The base wrapped test from wrapVitestKyselyTransaction
+ * @param fixtures - Object mapping fixture names to creator functions
+ * @returns An extended test API with both trx and the additional fixtures
+ *
+ * @example
+ * ```typescript
+ * import { test } from 'vitest';
+ * import { wrapVitestKyselyTransaction, extendWithFixtures, KyselyFactory } from '@geekmidas/testkit/kysely';
+ *
+ * // Define your builders
+ * const builders = {
+ *   user: KyselyFactory.createBuilder<DB, 'users'>('users', ({ faker }) => ({
+ *     name: faker.person.fullName(),
+ *     email: faker.internet.email(),
+ *   })),
+ * };
+ *
+ * // Create base wrapped test
+ * const baseTest = wrapVitestKyselyTransaction<DB>(test, db, createTestTables);
+ *
+ * // Extend with fixtures - each fixture receives the transaction
+ * const it = extendWithFixtures<DB, { factory: KyselyFactory<DB, typeof builders, {}> }>(
+ *   baseTest,
+ *   {
+ *     factory: (trx) => new KyselyFactory(builders, {}, trx),
+ *   }
+ * );
+ *
+ * // Use in tests - both trx and factory are available
+ * it('should create user with factory', async ({ trx, factory }) => {
+ *   const user = await factory.insert('user', { name: 'Test User' });
+ *   expect(user.id).toBeDefined();
+ *
+ *   // Verify in database
+ *   const found = await trx
+ *     .selectFrom('users')
+ *     .where('id', '=', user.id)
+ *     .selectAll()
+ *     .executeTakeFirst();
+ *   expect(found?.name).toBe('Test User');
+ * });
+ * ```
+ */
+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;
+};
 //#endregion
-export { IsolationLevel, KyselyFactory, PostgresKyselyMigrator, VitestKyselyTransactionIsolator, wrapVitestKyselyTransaction };
+export { FakerFactory, FixtureCreators, IsolationLevel, KyselyFactory, PostgresKyselyMigrator, VitestKyselyTransactionIsolator, extendWithFixtures, faker, wrapVitestKyselyTransaction };
 //# sourceMappingURL=kysely.d.cts.map

package/dist/kysely.d.mts

@@ -1,10 +1,10 @@
-import "./faker-Br8MzXil.mjs";
-import "./Factory-CRquB4vz.mjs";
-import { KyselyFactory } from "./KyselyFactory-BDS_QqRT.mjs";
+import { FakerFactory, faker } from "./faker-DHh7xs4u.mjs";
+import "./Factory-Cmr3s3-s.mjs";
+import { KyselyFactory } from "./KyselyFactory-BTdygZ-i.mjs";
 import "./PostgresMigrator-DQaRxoaY.mjs";
 import { PostgresKyselyMigrator } from "./PostgresKyselyMigrator-CIx3AFSR.mjs";
-import { DatabaseConnection, IsolationLevel } from "./VitestTransactionIsolator-CsfJBxcb.mjs";
-import { VitestKyselyTransactionIsolator } from "./VitestKyselyTransactionIsolator-COCVfvfr.mjs";
+import { DatabaseConnection, DatabaseFixtures, FixtureCreators, IsolationLevel } from "./VitestTransactionIsolator-DWDbnITQ.mjs";
+import { VitestKyselyTransactionIsolator } from "./VitestKyselyTransactionIsolator-DnyZMaA-.mjs";
 import { Kysely, Transaction } from "kysely";
 import { TestAPI } from "vitest";
 
@@ -69,6 +69,59 @@ import { TestAPI } from "vitest";
 declare function wrapVitestKyselyTransaction<Database>(api: TestAPI, connection: DatabaseConnection<Kysely<Database>>, setup?: (trx: Transaction<Database>) => Promise<void>, level?: IsolationLevel): TestAPI<{
   trx: Transaction<Database>;
 }>;
+/**
+ * Extends a Kysely transaction-wrapped test with additional fixtures.
+ * Each fixture receives the transaction and can create dependencies like factories or repositories.
+ *
+ * @template Database - The database schema type
+ * @template Extended - The type of additional fixtures to provide
+ * @param wrappedTest - The base wrapped test from wrapVitestKyselyTransaction
+ * @param fixtures - Object mapping fixture names to creator functions
+ * @returns An extended test API with both trx and the additional fixtures
+ *
+ * @example
+ * ```typescript
+ * import { test } from 'vitest';
+ * import { wrapVitestKyselyTransaction, extendWithFixtures, KyselyFactory } from '@geekmidas/testkit/kysely';
+ *
+ * // Define your builders
+ * const builders = {
+ *   user: KyselyFactory.createBuilder<DB, 'users'>('users', ({ faker }) => ({
+ *     name: faker.person.fullName(),
+ *     email: faker.internet.email(),
+ *   })),
+ * };
+ *
+ * // Create base wrapped test
+ * const baseTest = wrapVitestKyselyTransaction<DB>(test, db, createTestTables);
+ *
+ * // Extend with fixtures - each fixture receives the transaction
+ * const it = extendWithFixtures<DB, { factory: KyselyFactory<DB, typeof builders, {}> }>(
+ *   baseTest,
+ *   {
+ *     factory: (trx) => new KyselyFactory(builders, {}, trx),
+ *   }
+ * );
+ *
+ * // Use in tests - both trx and factory are available
+ * it('should create user with factory', async ({ trx, factory }) => {
+ *   const user = await factory.insert('user', { name: 'Test User' });
+ *   expect(user.id).toBeDefined();
+ *
+ *   // Verify in database
+ *   const found = await trx
+ *     .selectFrom('users')
+ *     .where('id', '=', user.id)
+ *     .selectAll()
+ *     .executeTakeFirst();
+ *   expect(found?.name).toBe('Test User');
+ * });
+ * ```
+ */
+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;
+};
 //#endregion
-export { IsolationLevel, KyselyFactory, PostgresKyselyMigrator, VitestKyselyTransactionIsolator, wrapVitestKyselyTransaction };
+export { FakerFactory, FixtureCreators, IsolationLevel, KyselyFactory, PostgresKyselyMigrator, VitestKyselyTransactionIsolator, extendWithFixtures, faker, wrapVitestKyselyTransaction };
 //# sourceMappingURL=kysely.d.mts.map

package/dist/kysely.mjs

@@ -1,10 +1,10 @@
 import "./Factory-z2m01hMj.mjs";
-import "./faker-BGKYFoCT.mjs";
-import { KyselyFactory } from "./KyselyFactory-BcYkC0t2.mjs";
+import { faker } from "./faker-BGKYFoCT.mjs";
+import { KyselyFactory } from "./KyselyFactory-CXY5gJk2.mjs";
 import "./PostgresMigrator-DbuJGAVy.mjs";
 import { PostgresKyselyMigrator } from "./PostgresKyselyMigrator-upT-hmrz.mjs";
-import { IsolationLevel } from "./VitestTransactionIsolator-CskiiJbW.mjs";
-import { VitestKyselyTransactionIsolator } from "./VitestKyselyTransactionIsolator-BxjlD1YM.mjs";
+import { IsolationLevel, extendWithFixtures } from "./VitestTransactionIsolator-BIaMs4c2.mjs";
+import { VitestKyselyTransactionIsolator } from "./VitestKyselyTransactionIsolator-XDL3ngs_.mjs";
 
 //#region src/kysely.ts
 /**
@@ -67,7 +67,59 @@ function wrapVitestKyselyTransaction(api, connection, setup, level = IsolationLe
 	const wrapper = new VitestKyselyTransactionIsolator(api);
 	return wrapper.wrapVitestWithTransaction(connection, setup, level);
 }
+/**
+* Extends a Kysely transaction-wrapped test with additional fixtures.
+* Each fixture receives the transaction and can create dependencies like factories or repositories.
+*
+* @template Database - The database schema type
+* @template Extended - The type of additional fixtures to provide
+* @param wrappedTest - The base wrapped test from wrapVitestKyselyTransaction
+* @param fixtures - Object mapping fixture names to creator functions
+* @returns An extended test API with both trx and the additional fixtures
+*
+* @example
+* ```typescript
+* import { test } from 'vitest';
+* import { wrapVitestKyselyTransaction, extendWithFixtures, KyselyFactory } from '@geekmidas/testkit/kysely';
+*
+* // Define your builders
+* const builders = {
+*   user: KyselyFactory.createBuilder<DB, 'users'>('users', ({ faker }) => ({
+*     name: faker.person.fullName(),
+*     email: faker.internet.email(),
+*   })),
+* };
+*
+* // Create base wrapped test
+* const baseTest = wrapVitestKyselyTransaction<DB>(test, db, createTestTables);
+*
+* // Extend with fixtures - each fixture receives the transaction
+* const it = extendWithFixtures<DB, { factory: KyselyFactory<DB, typeof builders, {}> }>(
+*   baseTest,
+*   {
+*     factory: (trx) => new KyselyFactory(builders, {}, trx),
+*   }
+* );
+*
+* // Use in tests - both trx and factory are available
+* it('should create user with factory', async ({ trx, factory }) => {
+*   const user = await factory.insert('user', { name: 'Test User' });
+*   expect(user.id).toBeDefined();
+*
+*   // Verify in database
+*   const found = await trx
+*     .selectFrom('users')
+*     .where('id', '=', user.id)
+*     .selectAll()
+*     .executeTakeFirst();
+*   expect(found?.name).toBe('Test User');
+* });
+* ```
+*/
+function extendWithFixtures$1(wrappedTest, fixtures) {
+	return extendWithFixtures(wrappedTest, fixtures);
+}
 
 //#endregion
-export { IsolationLevel, KyselyFactory, PostgresKyselyMigrator, VitestKyselyTransactionIsolator, wrapVitestKyselyTransaction };
+export { IsolationLevel, KyselyFactory, PostgresKyselyMigrator, VitestKyselyTransactionIsolator, extendWithFixtures$1 as extendWithFixtures, faker, wrapVitestKyselyTransaction };
 //# sourceMappingURL=kysely.mjs.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"],"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  IsolationLevel,\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';\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"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA0EA,SAAgB,4BACdA,KACAC,YACAC,OACAC,QAAwB,eAAe,iBACvC;CACA,MAAM,UAAU,IAAI,gCAA0C;AAE9D,QAAO,QAAQ,0BAA0B,YAAY,OAAO,MAAM;AACnE"}
+{"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"}

package/dist/objection.cjs

@@ -1,10 +1,10 @@
 require('./Factory-WMhTNZ9S.cjs');
-require('./faker-B14IEMIN.cjs');
-const require_ObjectionFactory = require('./ObjectionFactory-CDriunkS.cjs');
+const require_faker = require('./faker-B14IEMIN.cjs');
+const require_ObjectionFactory = require('./ObjectionFactory-Eb04AOnv.cjs');
 require('./PostgresMigrator-DFcNdCvD.cjs');
 const require_PostgresObjectionMigrator = require('./PostgresObjectionMigrator-BG6ymgnt.cjs');
-const require_VitestTransactionIsolator = require('./VitestTransactionIsolator-BQ5FpLtC.cjs');
-const require_VitestObjectionTransactionIsolator = require('./VitestObjectionTransactionIsolator-DzeF4UAq.cjs');
+const require_VitestTransactionIsolator = require('./VitestTransactionIsolator-BKIrj3Uy.cjs');
+const require_VitestObjectionTransactionIsolator = require('./VitestObjectionTransactionIsolator-D_tlOtq8.cjs');
 
 //#region src/objection.ts
 /**
@@ -82,11 +82,61 @@ function wrapVitestObjectionTransaction(api, conn, setup, level = require_Vitest
 	const wrapper = new require_VitestObjectionTransactionIsolator.VitestObjectionTransactionIsolator(api);
 	return wrapper.wrapVitestWithTransaction(conn, setup, level);
 }
+/**
+* Extends an Objection.js transaction-wrapped test with additional fixtures.
+* Each fixture receives the transaction and can create dependencies like factories or repositories.
+*
+* @template Extended - The type of additional fixtures to provide
+* @param wrappedTest - The base wrapped test from wrapVitestObjectionTransaction
+* @param fixtures - Object mapping fixture names to creator functions
+* @returns An extended test API with both trx and the additional fixtures
+*
+* @example
+* ```typescript
+* import { test } from 'vitest';
+* import { wrapVitestObjectionTransaction, extendWithFixtures, ObjectionFactory } from '@geekmidas/testkit/objection';
+* import { User } from './models';
+*
+* // Define your builders
+* const builders = {
+*   user: ObjectionFactory.createBuilder(User, ({ faker }) => ({
+*     name: faker.person.fullName(),
+*     email: faker.internet.email(),
+*   })),
+* };
+*
+* // Create base wrapped test
+* const baseTest = wrapVitestObjectionTransaction(test, knex, createTestTables);
+*
+* // Extend with fixtures - each fixture receives the transaction
+* const it = extendWithFixtures<{ factory: ObjectionFactory<typeof builders, {}> }>(
+*   baseTest,
+*   {
+*     factory: (trx) => new ObjectionFactory(builders, {}, trx),
+*   }
+* );
+*
+* // Use in tests - both trx and factory are available
+* it('should create user with factory', async ({ trx, factory }) => {
+*   const user = await factory.insert('user', { name: 'Test User' });
+*   expect(user.id).toBeDefined();
+*
+*   // Verify in database
+*   const found = await User.query(trx).findById(user.id);
+*   expect(found?.name).toBe('Test User');
+* });
+* ```
+*/
+function extendWithFixtures$1(wrappedTest, fixtures) {
+	return require_VitestTransactionIsolator.extendWithFixtures(wrappedTest, fixtures);
+}
 
 //#endregion
 exports.IsolationLevel = require_VitestTransactionIsolator.IsolationLevel;
 exports.ObjectionFactory = require_ObjectionFactory.ObjectionFactory;
 exports.PostgresObjectionMigrator = require_PostgresObjectionMigrator.PostgresObjectionMigrator;
 exports.VitestObjectionTransactionIsolator = require_VitestObjectionTransactionIsolator.VitestObjectionTransactionIsolator;
+exports.extendWithFixtures = extendWithFixtures$1;
+exports.faker = require_faker.faker;
 exports.wrapVitestObjectionTransaction = wrapVitestObjectionTransaction;
 //# sourceMappingURL=objection.cjs.map

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"],"sources":["../src/objection.ts"],"sourcesContent":["import type { Knex } from 'knex';\nimport type { TestAPI } from 'vitest';\nimport { VitestObjectionTransactionIsolator } from './VitestObjectionTransactionIsolator';\nimport {\n  type DatabaseConnection,\n  IsolationLevel,\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';\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"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA0FA,SAAgB,+BACdA,KACAC,MACAC,OACAC,QAAwBC,iDAAe,iBACvC;CACA,MAAM,UAAU,IAAIC,8EAAmC;AAEvD,QAAO,QAAQ,0BAA0B,MAAM,OAAO,MAAM;AAC7D"}
+{"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"}

package/dist/objection.d.cts

@@ -1,10 +1,10 @@
-import "./faker-Cg76aFNO.cjs";
+import { FakerFactory, faker } from "./faker-Cg76aFNO.cjs";
 import "./Factory-BZ8uMoXl.cjs";
-import { ObjectionFactory } from "./ObjectionFactory-C4X78k0B.cjs";
+import { ObjectionFactory } from "./ObjectionFactory-CeSIN3kZ.cjs";
 import "./PostgresMigrator-D5UkK1_K.cjs";
 import { PostgresObjectionMigrator } from "./PostgresObjectionMigrator-CZHHcCOv.cjs";
-import { DatabaseConnection, IsolationLevel } from "./VitestTransactionIsolator-DdLNODZg.cjs";
-import { VitestObjectionTransactionIsolator } from "./VitestObjectionTransactionIsolator-CJ4ds5Qv.cjs";
+import { DatabaseConnection, DatabaseFixtures, FixtureCreators, IsolationLevel } from "./VitestTransactionIsolator-CyG_i_Nj.cjs";
+import { VitestObjectionTransactionIsolator } from "./VitestObjectionTransactionIsolator-COVDlpEo.cjs";
 import { Knex } from "knex";
 import { TestAPI } from "vitest";
 
@@ -84,6 +84,55 @@ import { TestAPI } from "vitest";
 declare function wrapVitestObjectionTransaction(api: TestAPI, conn: DatabaseConnection<Knex>, setup?: (trx: Knex.Transaction) => Promise<void>, level?: IsolationLevel): TestAPI<{
   trx: Knex.Transaction<any, any[]>;
 }>;
+/**
+ * Extends an Objection.js transaction-wrapped test with additional fixtures.
+ * Each fixture receives the transaction and can create dependencies like factories or repositories.
+ *
+ * @template Extended - The type of additional fixtures to provide
+ * @param wrappedTest - The base wrapped test from wrapVitestObjectionTransaction
+ * @param fixtures - Object mapping fixture names to creator functions
+ * @returns An extended test API with both trx and the additional fixtures
+ *
+ * @example
+ * ```typescript
+ * import { test } from 'vitest';
+ * import { wrapVitestObjectionTransaction, extendWithFixtures, ObjectionFactory } from '@geekmidas/testkit/objection';
+ * import { User } from './models';
+ *
+ * // Define your builders
+ * const builders = {
+ *   user: ObjectionFactory.createBuilder(User, ({ faker }) => ({
+ *     name: faker.person.fullName(),
+ *     email: faker.internet.email(),
+ *   })),
+ * };
+ *
+ * // Create base wrapped test
+ * const baseTest = wrapVitestObjectionTransaction(test, knex, createTestTables);
+ *
+ * // Extend with fixtures - each fixture receives the transaction
+ * const it = extendWithFixtures<{ factory: ObjectionFactory<typeof builders, {}> }>(
+ *   baseTest,
+ *   {
+ *     factory: (trx) => new ObjectionFactory(builders, {}, trx),
+ *   }
+ * );
+ *
+ * // Use in tests - both trx and factory are available
+ * it('should create user with factory', async ({ trx, factory }) => {
+ *   const user = await factory.insert('user', { name: 'Test User' });
+ *   expect(user.id).toBeDefined();
+ *
+ *   // Verify in database
+ *   const found = await User.query(trx).findById(user.id);
+ *   expect(found?.name).toBe('Test User');
+ * });
+ * ```
+ */
+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;
+};
 //#endregion
-export { IsolationLevel, ObjectionFactory, PostgresObjectionMigrator, VitestObjectionTransactionIsolator, wrapVitestObjectionTransaction };
+export { FakerFactory, FixtureCreators, IsolationLevel, ObjectionFactory, PostgresObjectionMigrator, VitestObjectionTransactionIsolator, extendWithFixtures, faker, wrapVitestObjectionTransaction };
 //# sourceMappingURL=objection.d.cts.map