@geekmidas/testkit 0.1.1 → 0.3.0

package/dist/{faker-BSH1EMtg.d.cts → faker-CbYiF-8_.d.cts}

@@ -1,4 +1,4 @@
-import * as _faker_js_faker0 from "@faker-js/faker";
+import * as _faker_js_faker3 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_faker0.Faker & {
+declare const faker: Readonly<_faker_js_faker3.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-BSH1EMtg.d.cts.map
+//# sourceMappingURL=faker-CbYiF-8_.d.cts.map

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

@@ -1,4 +1,4 @@
-import * as _faker_js_faker0 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_faker0.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-D9gz7KjY.d.mts.map
+//# sourceMappingURL=faker-DHh7xs4u.d.mts.map

package/dist/faker.d.cts

@@ -1,2 +1,2 @@
-import { FakerFactory, Timestamps, coordinateInRadius, faker, identifier, resetAllSequences, resetSequence, sequence, timestamps } from "./faker-BSH1EMtg.cjs";
+import { FakerFactory, Timestamps, coordinateInRadius, faker, identifier, resetAllSequences, resetSequence, sequence, timestamps } from "./faker-CbYiF-8_.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-D9gz7KjY.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('./Factory-BhjUOBWN.cjs');
 const require_faker = require('./faker-B14IEMIN.cjs');
-const require_KyselyFactory = require('./KyselyFactory-DaaCykWP.cjs');
+const require_KyselyFactory = require('./KyselyFactory-BFqVIn_0.cjs');
 require('./PostgresMigrator-DFcNdCvD.cjs');
 const require_PostgresKyselyMigrator = require('./PostgresKyselyMigrator-CfytARcA.cjs');
-const require_VitestTransactionIsolator = require('./VitestTransactionIsolator-BKIrj3Uy.cjs');
-const require_VitestKyselyTransactionIsolator = require('./VitestKyselyTransactionIsolator-DX_VPKS-.cjs');
+const require_VitestTransactionIsolator = require('./VitestTransactionIsolator-CMfJXZP8.cjs');
+const require_VitestKyselyTransactionIsolator = require('./VitestKyselyTransactionIsolator-EvDLk5zg.cjs');
 
 //#region src/kysely.ts
 /**
@@ -13,10 +13,9 @@ const require_VitestKyselyTransactionIsolator = require('./VitestKyselyTransacti
 * This ensures tests don't affect each other's data and run faster than truncating tables.
 *
 * @template Database - The database schema type
+* @template Extended - Additional fixtures to provide
 * @param api - The Vitest test API (usually `test` from vitest)
-* @param db - The Kysely database instance
-* @param setup - Optional setup function to run before each test in the transaction
-* @param level - Transaction isolation level (defaults to REPEATABLE_READ)
+* @param options - Configuration options for transaction wrapping
 * @returns A wrapped test API that provides transaction isolation
 *
 * @example
@@ -26,7 +25,9 @@ const require_VitestKyselyTransactionIsolator = require('./VitestKyselyTransacti
 * import { db } from './database';
 *
 * // Create isolated test with automatic rollback
-* const isolatedTest = wrapVitestKyselyTransaction(test, db);
+* const isolatedTest = wrapVitestKyselyTransaction(test, {
+*   connection: db,
+* });
 *
 * // Use in tests - each test gets its own transaction
 * isolatedTest('should create user', async ({ trx }) => {
@@ -37,35 +38,25 @@ const require_VitestKyselyTransactionIsolator = require('./VitestKyselyTransacti
 *     .executeTakeFirst();
 *
 *   expect(user).toBeDefined();
-*   // User is automatically rolled back after test
 * });
 *
-* // With setup function for common test data
-* const testWithSetup = wrapVitestKyselyTransaction(
-*   test,
-*   db,
-*   async (trx) => {
-*     // Create common test data
-*     await trx.insertInto('settings')
-*       .values({ key: 'test_mode', value: 'true' })
-*       .execute();
-*   }
-* );
-*
-* testWithSetup('should have test settings', async ({ trx }) => {
-*   const setting = await trx
-*     .selectFrom('settings')
-*     .where('key', '=', 'test_mode')
-*     .selectAll()
-*     .executeTakeFirst();
+* // With fixtures for factories
+* const it = wrapVitestKyselyTransaction<DB, { factory: Factory }>(test, {
+*   connection: db,
+*   fixtures: {
+*     factory: (trx) => new Factory(trx),
+*   },
+* });
 *
-*   expect(setting?.value).toBe('true');
+* it('should create user with factory', async ({ trx, factory }) => {
+*   const user = await factory.insert('user', { name: 'Test' });
+*   expect(user.id).toBeDefined();
 * });
 * ```
 */
-function wrapVitestKyselyTransaction(api, connection, setup, level = require_VitestTransactionIsolator.IsolationLevel.REPEATABLE_READ) {
+function wrapVitestKyselyTransaction(api, options) {
 	const wrapper = new require_VitestKyselyTransactionIsolator.VitestKyselyTransactionIsolator(api);
-	return wrapper.wrapVitestWithTransaction(connection, setup, level);
+	return wrapper.wrapVitestWithTransaction(options);
 }
 /**
 * Extends a Kysely transaction-wrapped test with additional fixtures.
@@ -91,7 +82,10 @@ function wrapVitestKyselyTransaction(api, connection, setup, level = require_Vit
 * };
 *
 * // Create base wrapped test
-* const baseTest = wrapVitestKyselyTransaction<DB>(test, db, createTestTables);
+* const baseTest = wrapVitestKyselyTransaction<DB>(test, {
+*   connection: db,
+*   setup: createTestTables,
+* });
 *
 * // Extend with fixtures - each fixture receives the transaction
 * const it = extendWithFixtures<DB, { factory: KyselyFactory<DB, typeof builders, {}> }>(

package/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 {\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"}
+{"version":3,"file":"kysely.cjs","names":["api: TestAPI","options: KyselyTransactionOptions<Database, Extended>","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  type 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 type { ExtractSeedAttrs, FactorySeed } from './Factory';\nexport { PostgresKyselyMigrator } from './PostgresKyselyMigrator';\nexport { VitestKyselyTransactionIsolator } from './VitestKyselyTransactionIsolator';\nexport { IsolationLevel } from './VitestTransactionIsolator';\nexport type {\n  DatabaseFixtures,\n  ExtendedDatabaseFixtures,\n  FixtureCreators,\n  TestWithExtendedFixtures,\n  TransactionWrapperOptions,\n} from './VitestTransactionIsolator';\n\n/**\n * Kysely-specific options for transaction wrapping.\n */\nexport interface KyselyTransactionOptions<\n  Database,\n  Extended extends Record<string, unknown> = {},\n> {\n  /** Function that creates or returns a Kysely database instance */\n  connection: DatabaseConnection<Kysely<Database>>;\n  /** Optional setup function to run within the transaction before each test */\n  setup?: (trx: Transaction<Database>) => Promise<void>;\n  /** Transaction isolation level (defaults to REPEATABLE_READ) */\n  isolationLevel?: IsolationLevel;\n  /** Additional fixtures that depend on the transaction */\n  fixtures?: FixtureCreators<Transaction<Database>, Extended>;\n}\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 * @template Extended - Additional fixtures to provide\n * @param api - The Vitest test API (usually `test` from vitest)\n * @param options - Configuration options for transaction wrapping\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, {\n *   connection: db,\n * });\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 * });\n *\n * // With fixtures for factories\n * const it = wrapVitestKyselyTransaction<DB, { factory: Factory }>(test, {\n *   connection: db,\n *   fixtures: {\n *     factory: (trx) => new Factory(trx),\n *   },\n * });\n *\n * it('should create user with factory', async ({ trx, factory }) => {\n *   const user = await factory.insert('user', { name: 'Test' });\n *   expect(user.id).toBeDefined();\n * });\n * ```\n */\nexport function wrapVitestKyselyTransaction<\n  Database,\n  Extended extends Record<string, unknown> = {},\n>(api: TestAPI, options: KyselyTransactionOptions<Database, Extended>) {\n  const wrapper = new VitestKyselyTransactionIsolator<Database>(api);\n\n  return wrapper.wrapVitestWithTransaction(options);\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, {\n *   connection: db,\n *   setup: createTestTables,\n * });\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":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+FA,SAAgB,4BAGdA,KAAcC,SAAuD;CACrE,MAAM,UAAU,IAAIC,wEAA0C;AAE9D,QAAO,QAAQ,0BAA0B,QAAQ;AAClD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAsDD,SAAgBC,qBAIdC,aAAgBC,UAA4D;AAC5E,QAAO,qDACL,aACA,SACD;AACF"}

package/dist/kysely.d.cts

@@ -1,25 +1,37 @@
-import { FakerFactory, faker } from "./faker-BSH1EMtg.cjs";
-import "./Factory-pNV7ZQ7-.cjs";
-import { KyselyFactory } from "./KyselyFactory-CPZTUuMB.cjs";
+import { FakerFactory, faker } from "./faker-CbYiF-8_.cjs";
+import { ExtractSeedAttrs, FactorySeed } from "./Factory-IdfEkOeT.cjs";
+import { KyselyFactory } from "./KyselyFactory-Dxhi_ZkA.cjs";
 import "./PostgresMigrator-D5UkK1_K.cjs";
 import { PostgresKyselyMigrator } from "./PostgresKyselyMigrator-CQ3aUoy_.cjs";
-import { DatabaseConnection, DatabaseFixtures, ExtendedDatabaseFixtures, FixtureCreators, IsolationLevel, TestWithExtendedFixtures } from "./VitestTransactionIsolator-DfA80g2M.cjs";
-import { VitestKyselyTransactionIsolator } from "./VitestKyselyTransactionIsolator-BqrZDeaT.cjs";
+import { DatabaseConnection, DatabaseFixtures, ExtendedDatabaseFixtures, FixtureCreators, IsolationLevel, TestWithExtendedFixtures, TransactionWrapperOptions } from "./VitestTransactionIsolator-CwQaxZLP.cjs";
+import { VitestKyselyTransactionIsolator } from "./VitestKyselyTransactionIsolator-D3EZZhjZ.cjs";
 import { Kysely, Transaction } from "kysely";
 import { TestAPI } from "vitest";
 
 //#region src/kysely.d.ts
 
+/**
+ * Kysely-specific options for transaction wrapping.
+ */
+interface KyselyTransactionOptions<Database, Extended extends Record<string, unknown> = {}> {
+  /** Function that creates or returns a Kysely database instance */
+  connection: DatabaseConnection<Kysely<Database>>;
+  /** Optional setup function to run within the transaction before each test */
+  setup?: (trx: Transaction<Database>) => Promise<void>;
+  /** Transaction isolation level (defaults to REPEATABLE_READ) */
+  isolationLevel?: IsolationLevel;
+  /** Additional fixtures that depend on the transaction */
+  fixtures?: FixtureCreators<Transaction<Database>, Extended>;
+}
 /**
  * Creates a wrapped Vitest test API with automatic transaction rollback for Kysely.
  * Each test runs in an isolated database transaction that is rolled back after completion.
  * This ensures tests don't affect each other's data and run faster than truncating tables.
  *
  * @template Database - The database schema type
+ * @template Extended - Additional fixtures to provide
  * @param api - The Vitest test API (usually `test` from vitest)
- * @param db - The Kysely database instance
- * @param setup - Optional setup function to run before each test in the transaction
- * @param level - Transaction isolation level (defaults to REPEATABLE_READ)
+ * @param options - Configuration options for transaction wrapping
  * @returns A wrapped test API that provides transaction isolation
  *
  * @example
@@ -29,7 +41,9 @@ import { TestAPI } from "vitest";
  * import { db } from './database';
  *
  * // Create isolated test with automatic rollback
- * const isolatedTest = wrapVitestKyselyTransaction(test, db);
+ * const isolatedTest = wrapVitestKyselyTransaction(test, {
+ *   connection: db,
+ * });
  *
  * // Use in tests - each test gets its own transaction
  * isolatedTest('should create user', async ({ trx }) => {
@@ -40,35 +54,23 @@ import { TestAPI } from "vitest";
  *     .executeTakeFirst();
  *
  *   expect(user).toBeDefined();
- *   // User is automatically rolled back after test
  * });
  *
- * // With setup function for common test data
- * const testWithSetup = wrapVitestKyselyTransaction(
- *   test,
- *   db,
- *   async (trx) => {
- *     // Create common test data
- *     await trx.insertInto('settings')
- *       .values({ key: 'test_mode', value: 'true' })
- *       .execute();
- *   }
- * );
- *
- * testWithSetup('should have test settings', async ({ trx }) => {
- *   const setting = await trx
- *     .selectFrom('settings')
- *     .where('key', '=', 'test_mode')
- *     .selectAll()
- *     .executeTakeFirst();
+ * // With fixtures for factories
+ * const it = wrapVitestKyselyTransaction<DB, { factory: Factory }>(test, {
+ *   connection: db,
+ *   fixtures: {
+ *     factory: (trx) => new Factory(trx),
+ *   },
+ * });
  *
- *   expect(setting?.value).toBe('true');
+ * it('should create user with factory', async ({ trx, factory }) => {
+ *   const user = await factory.insert('user', { name: 'Test' });
+ *   expect(user.id).toBeDefined();
  * });
  * ```
  */
-declare function wrapVitestKyselyTransaction<Database>(api: TestAPI, connection: DatabaseConnection<Kysely<Database>>, setup?: (trx: Transaction<Database>) => Promise<void>, level?: IsolationLevel): TestAPI<{
-  trx: Transaction<Database>;
-}>;
+declare function wrapVitestKyselyTransaction<Database, Extended extends Record<string, unknown> = {}>(api: TestAPI, options: KyselyTransactionOptions<Database, Extended>): TestAPI<DatabaseFixtures<Transaction<Database>, object> & Extended>;
 /**
  * Extends a Kysely transaction-wrapped test with additional fixtures.
  * Each fixture receives the transaction and can create dependencies like factories or repositories.
@@ -93,7 +95,10 @@ declare function wrapVitestKyselyTransaction<Database>(api: TestAPI, connection:
  * };
  *
  * // Create base wrapped test
- * const baseTest = wrapVitestKyselyTransaction<DB>(test, db, createTestTables);
+ * const baseTest = wrapVitestKyselyTransaction<DB>(test, {
+ *   connection: db,
+ *   setup: createTestTables,
+ * });
  *
  * // Extend with fixtures - each fixture receives the transaction
  * const it = extendWithFixtures<DB, { factory: KyselyFactory<DB, typeof builders, {}> }>(
@@ -120,5 +125,5 @@ 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>): TestWithExtendedFixtures<Transaction<Database>, Extended, T>;
 //#endregion
-export { DatabaseFixtures, ExtendedDatabaseFixtures, FakerFactory, FixtureCreators, IsolationLevel, KyselyFactory, PostgresKyselyMigrator, TestWithExtendedFixtures, VitestKyselyTransactionIsolator, extendWithFixtures, faker, wrapVitestKyselyTransaction };
+export { DatabaseFixtures, ExtendedDatabaseFixtures, ExtractSeedAttrs, FactorySeed, FakerFactory, FixtureCreators, IsolationLevel, KyselyFactory, KyselyTransactionOptions, PostgresKyselyMigrator, TestWithExtendedFixtures, TransactionWrapperOptions, VitestKyselyTransactionIsolator, extendWithFixtures, faker, wrapVitestKyselyTransaction };
 //# sourceMappingURL=kysely.d.cts.map

package/dist/kysely.d.mts

@@ -1,25 +1,37 @@
-import { FakerFactory, faker } from "./faker-D9gz7KjY.mjs";
-import "./Factory-DE3hE0WO.mjs";
-import { KyselyFactory } from "./KyselyFactory-RAyvZ8Cj.mjs";
+import { FakerFactory, faker } from "./faker-DHh7xs4u.mjs";
+import { ExtractSeedAttrs, FactorySeed } from "./Factory-BcGJjLc8.mjs";
+import { KyselyFactory } from "./KyselyFactory-Cj-EultY.mjs";
 import "./PostgresMigrator-DQaRxoaY.mjs";
 import { PostgresKyselyMigrator } from "./PostgresKyselyMigrator-CIx3AFSR.mjs";
-import { DatabaseConnection, DatabaseFixtures, ExtendedDatabaseFixtures, FixtureCreators, IsolationLevel, TestWithExtendedFixtures } from "./VitestTransactionIsolator-DLdQlfZ5.mjs";
-import { VitestKyselyTransactionIsolator } from "./VitestKyselyTransactionIsolator-DiskaURs.mjs";
+import { DatabaseConnection, DatabaseFixtures, ExtendedDatabaseFixtures, FixtureCreators, IsolationLevel, TestWithExtendedFixtures, TransactionWrapperOptions } from "./VitestTransactionIsolator-BvR19bYn.mjs";
+import { VitestKyselyTransactionIsolator } from "./VitestKyselyTransactionIsolator-Dxlp1u0f.mjs";
 import { Kysely, Transaction } from "kysely";
 import { TestAPI } from "vitest";
 
 //#region src/kysely.d.ts
 
+/**
+ * Kysely-specific options for transaction wrapping.
+ */
+interface KyselyTransactionOptions<Database, Extended extends Record<string, unknown> = {}> {
+  /** Function that creates or returns a Kysely database instance */
+  connection: DatabaseConnection<Kysely<Database>>;
+  /** Optional setup function to run within the transaction before each test */
+  setup?: (trx: Transaction<Database>) => Promise<void>;
+  /** Transaction isolation level (defaults to REPEATABLE_READ) */
+  isolationLevel?: IsolationLevel;
+  /** Additional fixtures that depend on the transaction */
+  fixtures?: FixtureCreators<Transaction<Database>, Extended>;
+}
 /**
  * Creates a wrapped Vitest test API with automatic transaction rollback for Kysely.
  * Each test runs in an isolated database transaction that is rolled back after completion.
  * This ensures tests don't affect each other's data and run faster than truncating tables.
  *
  * @template Database - The database schema type
+ * @template Extended - Additional fixtures to provide
  * @param api - The Vitest test API (usually `test` from vitest)
- * @param db - The Kysely database instance
- * @param setup - Optional setup function to run before each test in the transaction
- * @param level - Transaction isolation level (defaults to REPEATABLE_READ)
+ * @param options - Configuration options for transaction wrapping
  * @returns A wrapped test API that provides transaction isolation
  *
  * @example
@@ -29,7 +41,9 @@ import { TestAPI } from "vitest";
  * import { db } from './database';
  *
  * // Create isolated test with automatic rollback
- * const isolatedTest = wrapVitestKyselyTransaction(test, db);
+ * const isolatedTest = wrapVitestKyselyTransaction(test, {
+ *   connection: db,
+ * });
  *
  * // Use in tests - each test gets its own transaction
  * isolatedTest('should create user', async ({ trx }) => {
@@ -40,35 +54,23 @@ import { TestAPI } from "vitest";
  *     .executeTakeFirst();
  *
  *   expect(user).toBeDefined();
- *   // User is automatically rolled back after test
  * });
  *
- * // With setup function for common test data
- * const testWithSetup = wrapVitestKyselyTransaction(
- *   test,
- *   db,
- *   async (trx) => {
- *     // Create common test data
- *     await trx.insertInto('settings')
- *       .values({ key: 'test_mode', value: 'true' })
- *       .execute();
- *   }
- * );
- *
- * testWithSetup('should have test settings', async ({ trx }) => {
- *   const setting = await trx
- *     .selectFrom('settings')
- *     .where('key', '=', 'test_mode')
- *     .selectAll()
- *     .executeTakeFirst();
+ * // With fixtures for factories
+ * const it = wrapVitestKyselyTransaction<DB, { factory: Factory }>(test, {
+ *   connection: db,
+ *   fixtures: {
+ *     factory: (trx) => new Factory(trx),
+ *   },
+ * });
  *
- *   expect(setting?.value).toBe('true');
+ * it('should create user with factory', async ({ trx, factory }) => {
+ *   const user = await factory.insert('user', { name: 'Test' });
+ *   expect(user.id).toBeDefined();
  * });
  * ```
  */
-declare function wrapVitestKyselyTransaction<Database>(api: TestAPI, connection: DatabaseConnection<Kysely<Database>>, setup?: (trx: Transaction<Database>) => Promise<void>, level?: IsolationLevel): TestAPI<{
-  trx: Transaction<Database>;
-}>;
+declare function wrapVitestKyselyTransaction<Database, Extended extends Record<string, unknown> = {}>(api: TestAPI, options: KyselyTransactionOptions<Database, Extended>): TestAPI<DatabaseFixtures<Transaction<Database>, object> & Extended>;
 /**
  * Extends a Kysely transaction-wrapped test with additional fixtures.
  * Each fixture receives the transaction and can create dependencies like factories or repositories.
@@ -93,7 +95,10 @@ declare function wrapVitestKyselyTransaction<Database>(api: TestAPI, connection:
  * };
  *
  * // Create base wrapped test
- * const baseTest = wrapVitestKyselyTransaction<DB>(test, db, createTestTables);
+ * const baseTest = wrapVitestKyselyTransaction<DB>(test, {
+ *   connection: db,
+ *   setup: createTestTables,
+ * });
  *
  * // Extend with fixtures - each fixture receives the transaction
  * const it = extendWithFixtures<DB, { factory: KyselyFactory<DB, typeof builders, {}> }>(
@@ -120,5 +125,5 @@ 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>): TestWithExtendedFixtures<Transaction<Database>, Extended, T>;
 //#endregion
-export { DatabaseFixtures, ExtendedDatabaseFixtures, FakerFactory, FixtureCreators, IsolationLevel, KyselyFactory, PostgresKyselyMigrator, TestWithExtendedFixtures, VitestKyselyTransactionIsolator, extendWithFixtures, faker, wrapVitestKyselyTransaction };
+export { DatabaseFixtures, ExtendedDatabaseFixtures, ExtractSeedAttrs, FactorySeed, FakerFactory, FixtureCreators, IsolationLevel, KyselyFactory, KyselyTransactionOptions, PostgresKyselyMigrator, TestWithExtendedFixtures, TransactionWrapperOptions, VitestKyselyTransactionIsolator, extendWithFixtures, faker, wrapVitestKyselyTransaction };
 //# sourceMappingURL=kysely.d.mts.map

package/dist/kysely.mjs

@@ -1,10 +1,10 @@
-import "./Factory-z2m01hMj.mjs";
+import "./Factory-BFVnMMCC.mjs";
 import { faker } from "./faker-BGKYFoCT.mjs";
-import { KyselyFactory } from "./KyselyFactory-CXY5gJk2.mjs";
+import { KyselyFactory } from "./KyselyFactory-DMswpwji.mjs";
 import "./PostgresMigrator-DbuJGAVy.mjs";
 import { PostgresKyselyMigrator } from "./PostgresKyselyMigrator-upT-hmrz.mjs";
-import { IsolationLevel, extendWithFixtures } from "./VitestTransactionIsolator-BIaMs4c2.mjs";
-import { VitestKyselyTransactionIsolator } from "./VitestKyselyTransactionIsolator-XDL3ngs_.mjs";
+import { IsolationLevel, extendWithFixtures } from "./VitestTransactionIsolator-DQ7tLqgV.mjs";
+import { VitestKyselyTransactionIsolator } from "./VitestKyselyTransactionIsolator-CNURW8y6.mjs";
 
 //#region src/kysely.ts
 /**
@@ -13,10 +13,9 @@ import { VitestKyselyTransactionIsolator } from "./VitestKyselyTransactionIsolat
 * This ensures tests don't affect each other's data and run faster than truncating tables.
 *
 * @template Database - The database schema type
+* @template Extended - Additional fixtures to provide
 * @param api - The Vitest test API (usually `test` from vitest)
-* @param db - The Kysely database instance
-* @param setup - Optional setup function to run before each test in the transaction
-* @param level - Transaction isolation level (defaults to REPEATABLE_READ)
+* @param options - Configuration options for transaction wrapping
 * @returns A wrapped test API that provides transaction isolation
 *
 * @example
@@ -26,7 +25,9 @@ import { VitestKyselyTransactionIsolator } from "./VitestKyselyTransactionIsolat
 * import { db } from './database';
 *
 * // Create isolated test with automatic rollback
-* const isolatedTest = wrapVitestKyselyTransaction(test, db);
+* const isolatedTest = wrapVitestKyselyTransaction(test, {
+*   connection: db,
+* });
 *
 * // Use in tests - each test gets its own transaction
 * isolatedTest('should create user', async ({ trx }) => {
@@ -37,35 +38,25 @@ import { VitestKyselyTransactionIsolator } from "./VitestKyselyTransactionIsolat
 *     .executeTakeFirst();
 *
 *   expect(user).toBeDefined();
-*   // User is automatically rolled back after test
 * });
 *
-* // With setup function for common test data
-* const testWithSetup = wrapVitestKyselyTransaction(
-*   test,
-*   db,
-*   async (trx) => {
-*     // Create common test data
-*     await trx.insertInto('settings')
-*       .values({ key: 'test_mode', value: 'true' })
-*       .execute();
-*   }
-* );
-*
-* testWithSetup('should have test settings', async ({ trx }) => {
-*   const setting = await trx
-*     .selectFrom('settings')
-*     .where('key', '=', 'test_mode')
-*     .selectAll()
-*     .executeTakeFirst();
+* // With fixtures for factories
+* const it = wrapVitestKyselyTransaction<DB, { factory: Factory }>(test, {
+*   connection: db,
+*   fixtures: {
+*     factory: (trx) => new Factory(trx),
+*   },
+* });
 *
-*   expect(setting?.value).toBe('true');
+* it('should create user with factory', async ({ trx, factory }) => {
+*   const user = await factory.insert('user', { name: 'Test' });
+*   expect(user.id).toBeDefined();
 * });
 * ```
 */
-function wrapVitestKyselyTransaction(api, connection, setup, level = IsolationLevel.REPEATABLE_READ) {
+function wrapVitestKyselyTransaction(api, options) {
 	const wrapper = new VitestKyselyTransactionIsolator(api);
-	return wrapper.wrapVitestWithTransaction(connection, setup, level);
+	return wrapper.wrapVitestWithTransaction(options);
 }
 /**
 * Extends a Kysely transaction-wrapped test with additional fixtures.
@@ -91,7 +82,10 @@ function wrapVitestKyselyTransaction(api, connection, setup, level = IsolationLe
 * };
 *
 * // Create base wrapped test
-* const baseTest = wrapVitestKyselyTransaction<DB>(test, db, createTestTables);
+* const baseTest = wrapVitestKyselyTransaction<DB>(test, {
+*   connection: db,
+*   setup: createTestTables,
+* });
 *
 * // Extend with fixtures - each fixture receives the transaction
 * const it = extendWithFixtures<DB, { factory: KyselyFactory<DB, typeof builders, {}> }>(

package/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 {\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"}
+{"version":3,"file":"kysely.mjs","names":["api: TestAPI","options: KyselyTransactionOptions<Database, Extended>","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  type 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 type { ExtractSeedAttrs, FactorySeed } from './Factory';\nexport { PostgresKyselyMigrator } from './PostgresKyselyMigrator';\nexport { VitestKyselyTransactionIsolator } from './VitestKyselyTransactionIsolator';\nexport { IsolationLevel } from './VitestTransactionIsolator';\nexport type {\n  DatabaseFixtures,\n  ExtendedDatabaseFixtures,\n  FixtureCreators,\n  TestWithExtendedFixtures,\n  TransactionWrapperOptions,\n} from './VitestTransactionIsolator';\n\n/**\n * Kysely-specific options for transaction wrapping.\n */\nexport interface KyselyTransactionOptions<\n  Database,\n  Extended extends Record<string, unknown> = {},\n> {\n  /** Function that creates or returns a Kysely database instance */\n  connection: DatabaseConnection<Kysely<Database>>;\n  /** Optional setup function to run within the transaction before each test */\n  setup?: (trx: Transaction<Database>) => Promise<void>;\n  /** Transaction isolation level (defaults to REPEATABLE_READ) */\n  isolationLevel?: IsolationLevel;\n  /** Additional fixtures that depend on the transaction */\n  fixtures?: FixtureCreators<Transaction<Database>, Extended>;\n}\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 * @template Extended - Additional fixtures to provide\n * @param api - The Vitest test API (usually `test` from vitest)\n * @param options - Configuration options for transaction wrapping\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, {\n *   connection: db,\n * });\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 * });\n *\n * // With fixtures for factories\n * const it = wrapVitestKyselyTransaction<DB, { factory: Factory }>(test, {\n *   connection: db,\n *   fixtures: {\n *     factory: (trx) => new Factory(trx),\n *   },\n * });\n *\n * it('should create user with factory', async ({ trx, factory }) => {\n *   const user = await factory.insert('user', { name: 'Test' });\n *   expect(user.id).toBeDefined();\n * });\n * ```\n */\nexport function wrapVitestKyselyTransaction<\n  Database,\n  Extended extends Record<string, unknown> = {},\n>(api: TestAPI, options: KyselyTransactionOptions<Database, Extended>) {\n  const wrapper = new VitestKyselyTransactionIsolator<Database>(api);\n\n  return wrapper.wrapVitestWithTransaction(options);\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, {\n *   connection: db,\n *   setup: createTestTables,\n * });\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":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+FA,SAAgB,4BAGdA,KAAcC,SAAuD;CACrE,MAAM,UAAU,IAAI,gCAA0C;AAE9D,QAAO,QAAQ,0BAA0B,QAAQ;AAClD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAsDD,SAAgBC,qBAIdC,aAAgBC,UAA4D;AAC5E,QAAO,mBACL,aACA,SACD;AACF"}