@geekmidas/testkit 0.1.1 → 0.3.0

package/src/benchmark.ts

@@ -0,0 +1,48 @@
+/**
+ * Generates an array of test records for benchmark data sets.
+ *
+ * @param count - Number of records to generate
+ * @returns Array of test data objects
+ */
+export function generateTestData(
+  count: number,
+): Array<{ id: string; name: string; value: number }> {
+  return Array.from({ length: count }, (_, i) => ({
+    id: `id-${i}`,
+    name: `Item ${i}`,
+    value: Math.random() * 1000,
+  }));
+}
+
+/**
+ * Generates unique keys for cache benchmarks to avoid collisions.
+ *
+ * @param prefix - Key prefix
+ * @param count - Number of keys to generate
+ * @returns Array of unique cache keys
+ */
+export function generateCacheKeys(prefix: string, count: number): string[] {
+  return Array.from({ length: count }, (_, i) => `${prefix}:${i}`);
+}
+
+/**
+ * Generates IP addresses for rate limit benchmarks.
+ *
+ * @param count - Number of IPs to generate
+ * @param subnet - Subnet prefix (default: '192.168.1')
+ * @returns Array of IP addresses
+ */
+export function generateIpAddresses(
+  count: number,
+  subnet: string = '192.168.1',
+): string[] {
+  return Array.from({ length: count }, (_, i) => `${subnet}.${i % 256}`);
+}
+
+/**
+ * Creates a random IP address for rate limit benchmarks.
+ */
+export function randomIpAddress(): string {
+  const octet = () => Math.floor(Math.random() * 256);
+  return `${octet()}.${octet()}.${octet()}.${octet()}`;
+}

package/src/kysely.ts

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

package/src/objection.ts

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

package/dist/Factory-WMhTNZ9S.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"Factory-WMhTNZ9S.cjs","names":["seedFn: Seed"],"sources":["../src/Factory.ts"],"sourcesContent":["import type { FakerFactory } from './faker';\n\n/**\n * Abstract base class for database factories used in testing.\n * Provides a standardized interface for creating test data using builder and seed patterns.\n *\n * @template Builders - Record of builder functions for creating individual entities\n * @template Seeds - Record of seed functions for creating complex test scenarios\n *\n * @example\n * ```typescript\n * // Define builders for creating individual records\n * const builders = {\n *   user: (attrs) => ({ name: 'Test User', email: 'test@example.com', ...attrs }),\n *   post: (attrs) => ({ title: 'Test Post', content: 'Content', ...attrs })\n * };\n *\n * // Define seeds for complex scenarios\n * const seeds = {\n *   userWithPosts: async (attrs, factory) => {\n *     const user = await factory.insert('user', attrs);\n *     await factory.insertMany(3, 'post', { userId: user.id });\n *     return user;\n *   }\n * };\n * ```\n */\nexport abstract class Factory<\n  Builders extends Record<string, any>,\n  Seeds extends Record<string, any>,\n> {\n  /**\n   * Creates a typed seed function with proper type inference.\n   * This is a utility method to help with TypeScript type checking when defining seeds.\n   *\n   * @template Seed - The seed function type\n   * @param seedFn - The seed function to wrap\n   * @returns The same seed function with proper typing\n   *\n   * @example\n   * ```typescript\n   * const userWithPostsSeed = Factory.createSeed(async (attrs, factory, db) => {\n   *   const user = await factory.insert('user', attrs);\n   *   return user;\n   * });\n   * ```\n   */\n  static createSeed<Seed extends FactorySeed>(seedFn: Seed): Seed {\n    return seedFn;\n  }\n  /**\n   * Inserts an object into the database using a builder function.\n   *\n   * @param builderName - The name of the builder to use\n   * @param attrs - The attributes to insert\n   */\n  abstract insert<K extends keyof Builders>(\n    builderName: K,\n    attrs?: Parameters<Builders[K]>[0],\n  ): Promise<Awaited<ReturnType<Builders[K]>>>;\n\n  /**\n   * Inserts multiple objects into the database\n   *\n   * @param count -  Number of objects to insert\n   * @param builderName - The name of the builder to use\n   * @param attrs - The attributes to insert\n   */\n  abstract insertMany<K extends keyof Builders>(\n    count: number,\n    builderName: K,\n    attrs?:\n      | Parameters<Builders[K]>[0]\n      | ((\n          idx: number,\n          faker: FakerFactory,\n        ) => Promise<Parameters<Builders[K]>[0]>),\n  ): Promise<Awaited<ReturnType<Builders[K]>>[]>;\n\n  /**\n   * Seeds the database using a seed function.\n   *\n   * @param seedName - The name of the seed to use\n   * @returns The result of the seed function\n   * @param attrs - The attributes to pass to the seed function\n   */\n  abstract seed<K extends keyof Seeds>(\n    seedName: K,\n    attrs?: Parameters<Seeds[K]>[0],\n  ): ReturnType<Seeds[K]>;\n}\n\n/**\n * Type definition for a factory builder function that can work with different database types.\n * Builders are responsible for creating individual database records with default values and relationships.\n *\n * @template Attrs - The attributes/input type for the builder\n * @template Factory - The factory instance type\n * @template Result - The type of object returned by the builder\n * @template DB - The database connection type (Kysely, Knex, etc.)\n *\n * @param attrs - Partial attributes to override defaults\n * @param factory - The factory instance for creating related records\n * @param db - The database connection\n * @returns The created record or a promise resolving to it\n *\n * @example\n * ```typescript\n * const userBuilder: MixedFactoryBuilder<UserAttrs, Factory, User, Kysely<DB>> =\n *   async (attrs, factory, db) => {\n *     return {\n *       id: faker.string.uuid(),\n *       name: faker.person.fullName(),\n *       email: faker.internet.email(),\n *       ...attrs\n *     };\n *   };\n * ```\n */\nexport type MixedFactoryBuilder<\n  Attrs = any,\n  Factory = any,\n  Result = any,\n  DB = any,\n> = (attrs: Attrs, factory: Factory, db: DB) => Result | Promise<Result>;\n\n/**\n * Type definition for a factory seed function used to create complex test scenarios.\n * Seeds typically create multiple related records to set up a complete test environment.\n *\n * @template Attrs - The attributes/input type for the seed\n * @template Factory - The factory instance type\n * @template Result - The type of object returned by the seed\n * @template DB - The database connection type (Kysely, Knex, etc.)\n *\n * @param attrs - Configuration attributes for the seed\n * @param factory - The factory instance for creating records\n * @param db - The database connection\n * @returns A promise resolving to the seed result\n *\n * @example\n * ```typescript\n * const userWithPostsSeed: FactorySeed<{ postCount?: number }, Factory, User, DB> =\n *   async (attrs, factory, db) => {\n *     const user = await factory.insert('user', attrs);\n *     const postCount = attrs.postCount || 3;\n *\n *     for (let i = 0; i < postCount; i++) {\n *       await factory.insert('post', { userId: user.id });\n *     }\n *\n *     return user;\n *   };\n * ```\n */\nexport type FactorySeed<Attrs = any, Factory = any, Result = any, DB = any> = (\n  attrs: Attrs,\n  factory: Factory,\n  db: DB,\n) => Promise<Result>;\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;AA2BA,IAAsB,UAAtB,MAGE;;;;;;;;;;;;;;;;;CAiBA,OAAO,WAAqCA,QAAoB;AAC9D,SAAO;CACR;AAyCF"}

package/dist/Factory-z2m01hMj.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"Factory-z2m01hMj.mjs","names":["seedFn: Seed"],"sources":["../src/Factory.ts"],"sourcesContent":["import type { FakerFactory } from './faker';\n\n/**\n * Abstract base class for database factories used in testing.\n * Provides a standardized interface for creating test data using builder and seed patterns.\n *\n * @template Builders - Record of builder functions for creating individual entities\n * @template Seeds - Record of seed functions for creating complex test scenarios\n *\n * @example\n * ```typescript\n * // Define builders for creating individual records\n * const builders = {\n *   user: (attrs) => ({ name: 'Test User', email: 'test@example.com', ...attrs }),\n *   post: (attrs) => ({ title: 'Test Post', content: 'Content', ...attrs })\n * };\n *\n * // Define seeds for complex scenarios\n * const seeds = {\n *   userWithPosts: async (attrs, factory) => {\n *     const user = await factory.insert('user', attrs);\n *     await factory.insertMany(3, 'post', { userId: user.id });\n *     return user;\n *   }\n * };\n * ```\n */\nexport abstract class Factory<\n  Builders extends Record<string, any>,\n  Seeds extends Record<string, any>,\n> {\n  /**\n   * Creates a typed seed function with proper type inference.\n   * This is a utility method to help with TypeScript type checking when defining seeds.\n   *\n   * @template Seed - The seed function type\n   * @param seedFn - The seed function to wrap\n   * @returns The same seed function with proper typing\n   *\n   * @example\n   * ```typescript\n   * const userWithPostsSeed = Factory.createSeed(async (attrs, factory, db) => {\n   *   const user = await factory.insert('user', attrs);\n   *   return user;\n   * });\n   * ```\n   */\n  static createSeed<Seed extends FactorySeed>(seedFn: Seed): Seed {\n    return seedFn;\n  }\n  /**\n   * Inserts an object into the database using a builder function.\n   *\n   * @param builderName - The name of the builder to use\n   * @param attrs - The attributes to insert\n   */\n  abstract insert<K extends keyof Builders>(\n    builderName: K,\n    attrs?: Parameters<Builders[K]>[0],\n  ): Promise<Awaited<ReturnType<Builders[K]>>>;\n\n  /**\n   * Inserts multiple objects into the database\n   *\n   * @param count -  Number of objects to insert\n   * @param builderName - The name of the builder to use\n   * @param attrs - The attributes to insert\n   */\n  abstract insertMany<K extends keyof Builders>(\n    count: number,\n    builderName: K,\n    attrs?:\n      | Parameters<Builders[K]>[0]\n      | ((\n          idx: number,\n          faker: FakerFactory,\n        ) => Promise<Parameters<Builders[K]>[0]>),\n  ): Promise<Awaited<ReturnType<Builders[K]>>[]>;\n\n  /**\n   * Seeds the database using a seed function.\n   *\n   * @param seedName - The name of the seed to use\n   * @returns The result of the seed function\n   * @param attrs - The attributes to pass to the seed function\n   */\n  abstract seed<K extends keyof Seeds>(\n    seedName: K,\n    attrs?: Parameters<Seeds[K]>[0],\n  ): ReturnType<Seeds[K]>;\n}\n\n/**\n * Type definition for a factory builder function that can work with different database types.\n * Builders are responsible for creating individual database records with default values and relationships.\n *\n * @template Attrs - The attributes/input type for the builder\n * @template Factory - The factory instance type\n * @template Result - The type of object returned by the builder\n * @template DB - The database connection type (Kysely, Knex, etc.)\n *\n * @param attrs - Partial attributes to override defaults\n * @param factory - The factory instance for creating related records\n * @param db - The database connection\n * @returns The created record or a promise resolving to it\n *\n * @example\n * ```typescript\n * const userBuilder: MixedFactoryBuilder<UserAttrs, Factory, User, Kysely<DB>> =\n *   async (attrs, factory, db) => {\n *     return {\n *       id: faker.string.uuid(),\n *       name: faker.person.fullName(),\n *       email: faker.internet.email(),\n *       ...attrs\n *     };\n *   };\n * ```\n */\nexport type MixedFactoryBuilder<\n  Attrs = any,\n  Factory = any,\n  Result = any,\n  DB = any,\n> = (attrs: Attrs, factory: Factory, db: DB) => Result | Promise<Result>;\n\n/**\n * Type definition for a factory seed function used to create complex test scenarios.\n * Seeds typically create multiple related records to set up a complete test environment.\n *\n * @template Attrs - The attributes/input type for the seed\n * @template Factory - The factory instance type\n * @template Result - The type of object returned by the seed\n * @template DB - The database connection type (Kysely, Knex, etc.)\n *\n * @param attrs - Configuration attributes for the seed\n * @param factory - The factory instance for creating records\n * @param db - The database connection\n * @returns A promise resolving to the seed result\n *\n * @example\n * ```typescript\n * const userWithPostsSeed: FactorySeed<{ postCount?: number }, Factory, User, DB> =\n *   async (attrs, factory, db) => {\n *     const user = await factory.insert('user', attrs);\n *     const postCount = attrs.postCount || 3;\n *\n *     for (let i = 0; i < postCount; i++) {\n *       await factory.insert('post', { userId: user.id });\n *     }\n *\n *     return user;\n *   };\n * ```\n */\nexport type FactorySeed<Attrs = any, Factory = any, Result = any, DB = any> = (\n  attrs: Attrs,\n  factory: Factory,\n  db: DB,\n) => Promise<Result>;\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;AA2BA,IAAsB,UAAtB,MAGE;;;;;;;;;;;;;;;;;CAiBA,OAAO,WAAqCA,QAAoB;AAC9D,SAAO;CACR;AAyCF"}

package/dist/KyselyFactory-CXY5gJk2.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"KyselyFactory-CXY5gJk2.mjs","names":["seedFn: Seed","builders: Builders","seeds: Seeds","db: Kysely<DB> | ControlledTransaction<DB, []>","table: TableName","defaults?: (context: {\n      attrs: Attrs;\n      factory: Factory;\n      db: Kysely<DB>;\n      faker: FakerFactory;\n    }) =>\n      | Partial<Insertable<DB[TableName]>>\n      | Promise<Partial<Insertable<DB[TableName]>>>","autoInsert?: boolean","attrs: Attrs","factory: Factory","db: Kysely<DB>","fakerInstance: FakerFactory","data: Partial<Insertable<DB[TableName]>>","builderName: K","attrs?: Parameters<Builders[K]>[0]","count: number","attrs?: any","promises: Promise<any>[]","seedName: K","attrs?: Parameters<Seeds[K]>[0]"],"sources":["../src/KyselyFactory.ts"],"sourcesContent":["import type {\n  ControlledTransaction,\n  Insertable,\n  Kysely,\n  Selectable,\n} from 'kysely';\nimport { Factory, type FactorySeed } from './Factory.ts';\nimport { type FakerFactory, faker } from './faker.ts';\n\n/**\n * Factory implementation for Kysely ORM, providing test data creation utilities.\n * Extends the base Factory class with Kysely-specific database operations.\n *\n * @template DB - The database schema type\n * @template Builders - Record of builder functions for creating entities\n * @template Seeds - Record of seed functions for complex test scenarios\n *\n * @example\n * ```typescript\n * // Define your database schema\n * interface Database {\n *   users: UsersTable;\n *   posts: PostsTable;\n * }\n *\n * // Create builders\n * const builders = {\n *   user: KyselyFactory.createBuilder<Database, 'users'>('users', ({ attrs, faker }) => ({\n *     id: faker.string.uuid(),\n *     name: faker.person.fullName(),\n *     email: faker.internet.email(),\n *     ...attrs\n *   })),\n *   post: KyselyFactory.createBuilder<Database, 'posts'>('posts', ({ attrs }) => ({\n *     title: 'Test Post',\n *     content: 'Test content',\n *     ...attrs\n *   }))\n * };\n *\n * // Create factory instance\n * const factory = new KyselyFactory(builders, seeds, db);\n *\n * // Use in tests\n * const user = await factory.insert('user', { name: 'John Doe' });\n * ```\n */\nexport class KyselyFactory<\n  DB,\n  Builders extends Record<string, any>,\n  Seeds extends Record<string, any>,\n> extends Factory<Builders, Seeds> {\n  /**\n   * Creates a typed seed function with proper type inference.\n   * Inherits from the base Factory class implementation.\n   *\n   * @template Seed - The seed function type\n   * @param seedFn - The seed function to wrap\n   * @returns The same seed function with proper typing\n   */\n  static createSeed<Seed extends FactorySeed>(seedFn: Seed): Seed {\n    return Factory.createSeed(seedFn);\n  }\n\n  /**\n   * Creates a new KyselyFactory instance.\n   *\n   * @param builders - Record of builder functions for creating individual entities\n   * @param seeds - Record of seed functions for creating complex test scenarios\n   * @param db - Kysely database instance or controlled transaction\n   */\n  constructor(\n    private builders: Builders,\n    private seeds: Seeds,\n    private db: Kysely<DB> | ControlledTransaction<DB, []>,\n  ) {\n    super();\n  }\n\n  /**\n   * Creates a typed builder function for a specific database table.\n   * This is a utility method that helps create builders with proper type inference for Kysely.\n   *\n   * @template DB - The database schema type\n   * @template TableName - The name of the table (must be a key of DB)\n   * @template Attrs - The attributes type for the builder (defaults to Partial<Insertable>)\n   * @template Factory - The factory instance type\n   * @template Result - The result type (defaults to Selectable of the table)\n   *\n   * @param table - The name of the database table\n   * @param defaults - Optional function to provide default values (receives destructured context)\n   * @param autoInsert - Whether to automatically insert the record (default: true)\n   * @returns A builder function that creates and optionally inserts records\n   *\n   * @example\n   * ```typescript\n   * // Create a simple builder with defaults - destructure only what you need\n   * const userBuilder = KyselyFactory.createBuilder<DB, 'users'>('users',\n   *   ({ attrs, faker }) => ({\n   *     id: faker.string.uuid(),\n   *     name: faker.person.fullName(),\n   *     email: faker.internet.email(),\n   *     createdAt: new Date(),\n   *     ...attrs\n   *   })\n   * );\n   *\n   * // Only need faker? Just destructure that\n   * const leaveTypeBuilder = KyselyFactory.createBuilder<DB, 'leaveTypes'>('leaveTypes',\n   *   ({ faker }) => ({\n   *     name: faker.helpers.arrayElement(['Annual', 'Sick', 'Maternity']),\n   *     code: faker.string.alpha({ length: 3, casing: 'upper' }),\n   *   })\n   * );\n   *\n   * // Create a builder that doesn't auto-insert (useful for nested inserts)\n   * const addressBuilder = KyselyFactory.createBuilder<DB, 'addresses'>('addresses',\n   *   ({ attrs }) => ({\n   *     street: '123 Main St',\n   *     city: 'Anytown',\n   *     ...attrs\n   *   }),\n   *   false // Don't auto-insert\n   * );\n   * ```\n   */\n  static createBuilder<\n    DB,\n    TableName extends keyof DB & string,\n    Attrs extends Partial<Insertable<DB[TableName]>> = Partial<\n      Insertable<DB[TableName]>\n    >,\n    Factory = any,\n    Result = Selectable<DB[TableName]>,\n  >(\n    table: TableName,\n    defaults?: (context: {\n      attrs: Attrs;\n      factory: Factory;\n      db: Kysely<DB>;\n      faker: FakerFactory;\n    }) =>\n      | Partial<Insertable<DB[TableName]>>\n      | Promise<Partial<Insertable<DB[TableName]>>>,\n    autoInsert?: boolean,\n  ): (\n    attrs: Attrs,\n    factory: Factory,\n    db: Kysely<DB>,\n    faker: FakerFactory,\n  ) => Promise<Result> {\n    return async (\n      attrs: Attrs,\n      factory: Factory,\n      db: Kysely<DB>,\n      fakerInstance: FakerFactory,\n    ) => {\n      // Start with attributes\n      let data: Partial<Insertable<DB[TableName]>> = { ...attrs };\n\n      // Apply defaults\n      if (defaults) {\n        const defaultValues = await defaults({\n          attrs,\n          factory,\n          db,\n          faker: fakerInstance,\n        });\n        data = { ...defaultValues, ...data };\n      }\n\n      // Handle insertion based on autoInsert flag\n      if (autoInsert !== false) {\n        // Auto insert is enabled by default\n        const result = await db\n          .insertInto(table)\n          .values(data as Insertable<DB[TableName]>)\n          .returningAll()\n          .executeTakeFirst();\n\n        if (!result) {\n          throw new Error(`Failed to insert into ${table}`);\n        }\n\n        return result as Result;\n      } else {\n        // Return object for factory to handle insertion\n        return { table, data } as any;\n      }\n    };\n  }\n\n  /**\n   * Inserts a single record into the database using the specified builder.\n   * The builder function is responsible for generating the record data with defaults\n   * and the factory handles the actual database insertion.\n   *\n   * @template K - The builder name (must be a key of Builders)\n   * @param builderName - The name of the builder to use\n   * @param attrs - Optional attributes to override builder defaults\n   * @returns A promise resolving to the inserted record\n   * @throws Error if the specified builder doesn't exist\n   *\n   * @example\n   * ```typescript\n   * // Insert with defaults\n   * const user = await factory.insert('user');\n   *\n   * // Insert with overrides\n   * const adminUser = await factory.insert('user', {\n   *   email: 'admin@example.com',\n   *   role: 'admin'\n   * });\n   *\n   * // Use the inserted record\n   * const post = await factory.insert('post', {\n   *   userId: user.id,\n   *   title: 'My First Post'\n   * });\n   * ```\n   */\n  async insert<K extends keyof Builders>(\n    builderName: K,\n    attrs?: Parameters<Builders[K]>[0],\n  ): Promise<Awaited<ReturnType<Builders[K]>>> {\n    if (!(builderName in this.builders)) {\n      throw new Error(\n        `Factory \"${\n          builderName as string\n        }\" does not exist. Make sure it is correct and registered in src/test/setup.ts`,\n      );\n    }\n\n    const result = await this.builders[builderName](\n      attrs || {},\n      this,\n      this.db,\n      faker,\n    );\n\n    // For Kysely, we expect the builder to return an object with table and data properties\n    // or to handle the insertion itself and return the inserted record\n    if (\n      result &&\n      typeof result === 'object' &&\n      'table' in result &&\n      'data' in result\n    ) {\n      // If the builder returns {table: string, data: object}, we insert it\n      const inserted = await this.db\n        .insertInto(result.table)\n        .values(result.data)\n        .returningAll()\n        .executeTakeFirst();\n\n      return inserted as any;\n    }\n\n    // Otherwise, assume the builder handled the insertion itself\n    return result;\n  }\n\n  /**\n   * Inserts multiple records into the database using the specified builder.\n   * Supports both static attributes and dynamic attribute generation via a function.\n   *\n   * @template K - The builder name (must be a key of Builders)\n   * @param count - The number of records to insert\n   * @param builderName - The name of the builder to use\n   * @param attrs - Static attributes or a function that generates attributes for each record\n   * @returns A promise resolving to an array of inserted records\n   * @throws Error if the specified builder doesn't exist\n   *\n   * @example\n   * ```typescript\n   * // Insert multiple with same attributes\n   * const users = await factory.insertMany(5, 'user', { role: 'member' });\n   *\n   * // Insert multiple with dynamic attributes\n   * const posts = await factory.insertMany(10, 'post', (idx, faker) => ({\n   *   title: `Post ${idx + 1}`,\n   *   content: faker.lorem.paragraph(),\n   *   publishedAt: faker.date.past()\n   * }));\n   *\n   * // Create users with sequential emails\n   * const admins = await factory.insertMany(3, 'user', (idx) => ({\n   *   email: `admin${idx + 1}@example.com`,\n   *   role: 'admin'\n   * }));\n   * ```\n   */\n  // Method overloads for better type inference\n  async insertMany<K extends keyof Builders>(\n    count: number,\n    builderName: K,\n    attrs?: Parameters<Builders[K]>[0],\n  ): Promise<Awaited<ReturnType<Builders[K]>>[]>;\n  async insertMany<K extends keyof Builders>(\n    count: number,\n    builderName: K,\n    attrs: (\n      idx: number,\n      faker: FakerFactory,\n    ) => Parameters<Builders[K]>[0] | Promise<Parameters<Builders[K]>[0]>,\n  ): Promise<Awaited<ReturnType<Builders[K]>>[]>;\n  async insertMany<K extends keyof Builders>(\n    count: number,\n    builderName: K,\n    attrs?: any,\n  ): Promise<Awaited<ReturnType<Builders[K]>>[]> {\n    if (!(builderName in this.builders)) {\n      throw new Error(\n        `Builder \"${\n          builderName as string\n        }\" is not registered in this factory. Make sure it is correct and registered in src/test/setup.ts`,\n      );\n    }\n\n    const promises: Promise<any>[] = [];\n\n    for (let i = 0; i < count; i++) {\n      const newAttrs =\n        typeof attrs === 'function' ? await attrs(i, faker) : attrs;\n      promises.push(this.insert(builderName, newAttrs));\n    }\n\n    return Promise.all(promises);\n  }\n\n  /**\n   * Executes a seed function to create complex test scenarios with multiple related records.\n   * Seeds are useful for setting up complete test environments with realistic data relationships.\n   *\n   * @template K - The seed name (must be a key of Seeds)\n   * @param seedName - The name of the seed to execute\n   * @param attrs - Optional configuration attributes for the seed\n   * @returns The result of the seed function (typically the primary record created)\n   * @throws Error if the specified seed doesn't exist\n   *\n   * @example\n   * ```typescript\n   * // Execute a simple seed\n   * const user = await factory.seed('userWithProfile');\n   *\n   * // Execute a seed with configuration\n   * const author = await factory.seed('authorWithBooks', {\n   *   bookCount: 5,\n   *   includeReviews: true\n   * });\n   *\n   * // Use seed result in tests\n   * const company = await factory.seed('companyWithDepartments', {\n   *   departmentCount: 3,\n   *   employeesPerDepartment: 10\n   * });\n   * expect(company.departments).toHaveLength(3);\n   * ```\n   */\n  seed<K extends keyof Seeds>(\n    seedName: K,\n    attrs?: Parameters<Seeds[K]>[0],\n  ): ReturnType<Seeds[K]> {\n    if (!(seedName in this.seeds)) {\n      throw new Error(\n        `Seed \"${\n          seedName as string\n        }\" is not registered in this factory. Make sure it is correct and registered in src/test/setup.ts`,\n      );\n    }\n\n    return this.seeds[seedName](attrs || {}, this, this.db);\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+CA,IAAa,gBAAb,cAIU,QAAyB;;;;;;;;;CASjC,OAAO,WAAqCA,QAAoB;AAC9D,SAAO,QAAQ,WAAW,OAAO;CAClC;;;;;;;;CASD,YACUC,UACAC,OACAC,IACR;AACA,SAAO;EAJC;EACA;EACA;CAGT;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAiDD,OAAO,cASLC,OACAC,UAQAC,YAMmB;AACnB,SAAO,OACLC,OACAC,SACAC,IACAC,kBACG;GAEH,IAAIC,OAA2C,EAAE,GAAG,MAAO;AAG3D,OAAI,UAAU;IACZ,MAAM,gBAAgB,MAAM,SAAS;KACnC;KACA;KACA;KACA,OAAO;IACR,EAAC;AACF,WAAO;KAAE,GAAG;KAAe,GAAG;IAAM;GACrC;AAGD,OAAI,eAAe,OAAO;IAExB,MAAM,SAAS,MAAM,GAClB,WAAW,MAAM,CACjB,OAAO,KAAkC,CACzC,cAAc,CACd,kBAAkB;AAErB,SAAK,OACH,OAAM,IAAI,OAAO,wBAAwB,MAAM;AAGjD,WAAO;GACR,MAEC,QAAO;IAAE;IAAO;GAAM;EAEzB;CACF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+BD,MAAM,OACJC,aACAC,OAC2C;AAC3C,QAAM,eAAe,KAAK,UACxB,OAAM,IAAI,OACP,WACC,YACD;EAIL,MAAM,SAAS,MAAM,KAAK,SAAS,aACjC,SAAS,CAAE,GACX,MACA,KAAK,IACL,MACD;AAID,MACE,iBACO,WAAW,YAClB,WAAW,UACX,UAAU,QACV;GAEA,MAAM,WAAW,MAAM,KAAK,GACzB,WAAW,OAAO,MAAM,CACxB,OAAO,OAAO,KAAK,CACnB,cAAc,CACd,kBAAkB;AAErB,UAAO;EACR;AAGD,SAAO;CACR;CA8CD,MAAM,WACJC,OACAF,aACAG,OAC6C;AAC7C,QAAM,eAAe,KAAK,UACxB,OAAM,IAAI,OACP,WACC,YACD;EAIL,MAAMC,WAA2B,CAAE;AAEnC,OAAK,IAAI,IAAI,GAAG,IAAI,OAAO,KAAK;GAC9B,MAAM,kBACG,UAAU,aAAa,MAAM,MAAM,GAAG,MAAM,GAAG;AACxD,YAAS,KAAK,KAAK,OAAO,aAAa,SAAS,CAAC;EAClD;AAED,SAAO,QAAQ,IAAI,SAAS;CAC7B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+BD,KACEC,UACAC,OACsB;AACtB,QAAM,YAAY,KAAK,OACrB,OAAM,IAAI,OACP,QACC,SACD;AAIL,SAAO,KAAK,MAAM,UAAU,SAAS,CAAE,GAAE,MAAM,KAAK,GAAG;CACxD;AACF"}

package/dist/KyselyFactory-DaaCykWP.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"KyselyFactory-DaaCykWP.cjs","names":["Factory","seedFn: Seed","builders: Builders","seeds: Seeds","db: Kysely<DB> | ControlledTransaction<DB, []>","table: TableName","defaults?: (context: {\n      attrs: Attrs;\n      factory: Factory;\n      db: Kysely<DB>;\n      faker: FakerFactory;\n    }) =>\n      | Partial<Insertable<DB[TableName]>>\n      | Promise<Partial<Insertable<DB[TableName]>>>","autoInsert?: boolean","attrs: Attrs","factory: Factory","db: Kysely<DB>","fakerInstance: FakerFactory","data: Partial<Insertable<DB[TableName]>>","builderName: K","attrs?: Parameters<Builders[K]>[0]","faker","count: number","attrs?: any","promises: Promise<any>[]","seedName: K","attrs?: Parameters<Seeds[K]>[0]"],"sources":["../src/KyselyFactory.ts"],"sourcesContent":["import type {\n  ControlledTransaction,\n  Insertable,\n  Kysely,\n  Selectable,\n} from 'kysely';\nimport { Factory, type FactorySeed } from './Factory.ts';\nimport { type FakerFactory, faker } from './faker.ts';\n\n/**\n * Factory implementation for Kysely ORM, providing test data creation utilities.\n * Extends the base Factory class with Kysely-specific database operations.\n *\n * @template DB - The database schema type\n * @template Builders - Record of builder functions for creating entities\n * @template Seeds - Record of seed functions for complex test scenarios\n *\n * @example\n * ```typescript\n * // Define your database schema\n * interface Database {\n *   users: UsersTable;\n *   posts: PostsTable;\n * }\n *\n * // Create builders\n * const builders = {\n *   user: KyselyFactory.createBuilder<Database, 'users'>('users', ({ attrs, faker }) => ({\n *     id: faker.string.uuid(),\n *     name: faker.person.fullName(),\n *     email: faker.internet.email(),\n *     ...attrs\n *   })),\n *   post: KyselyFactory.createBuilder<Database, 'posts'>('posts', ({ attrs }) => ({\n *     title: 'Test Post',\n *     content: 'Test content',\n *     ...attrs\n *   }))\n * };\n *\n * // Create factory instance\n * const factory = new KyselyFactory(builders, seeds, db);\n *\n * // Use in tests\n * const user = await factory.insert('user', { name: 'John Doe' });\n * ```\n */\nexport class KyselyFactory<\n  DB,\n  Builders extends Record<string, any>,\n  Seeds extends Record<string, any>,\n> extends Factory<Builders, Seeds> {\n  /**\n   * Creates a typed seed function with proper type inference.\n   * Inherits from the base Factory class implementation.\n   *\n   * @template Seed - The seed function type\n   * @param seedFn - The seed function to wrap\n   * @returns The same seed function with proper typing\n   */\n  static createSeed<Seed extends FactorySeed>(seedFn: Seed): Seed {\n    return Factory.createSeed(seedFn);\n  }\n\n  /**\n   * Creates a new KyselyFactory instance.\n   *\n   * @param builders - Record of builder functions for creating individual entities\n   * @param seeds - Record of seed functions for creating complex test scenarios\n   * @param db - Kysely database instance or controlled transaction\n   */\n  constructor(\n    private builders: Builders,\n    private seeds: Seeds,\n    private db: Kysely<DB> | ControlledTransaction<DB, []>,\n  ) {\n    super();\n  }\n\n  /**\n   * Creates a typed builder function for a specific database table.\n   * This is a utility method that helps create builders with proper type inference for Kysely.\n   *\n   * @template DB - The database schema type\n   * @template TableName - The name of the table (must be a key of DB)\n   * @template Attrs - The attributes type for the builder (defaults to Partial<Insertable>)\n   * @template Factory - The factory instance type\n   * @template Result - The result type (defaults to Selectable of the table)\n   *\n   * @param table - The name of the database table\n   * @param defaults - Optional function to provide default values (receives destructured context)\n   * @param autoInsert - Whether to automatically insert the record (default: true)\n   * @returns A builder function that creates and optionally inserts records\n   *\n   * @example\n   * ```typescript\n   * // Create a simple builder with defaults - destructure only what you need\n   * const userBuilder = KyselyFactory.createBuilder<DB, 'users'>('users',\n   *   ({ attrs, faker }) => ({\n   *     id: faker.string.uuid(),\n   *     name: faker.person.fullName(),\n   *     email: faker.internet.email(),\n   *     createdAt: new Date(),\n   *     ...attrs\n   *   })\n   * );\n   *\n   * // Only need faker? Just destructure that\n   * const leaveTypeBuilder = KyselyFactory.createBuilder<DB, 'leaveTypes'>('leaveTypes',\n   *   ({ faker }) => ({\n   *     name: faker.helpers.arrayElement(['Annual', 'Sick', 'Maternity']),\n   *     code: faker.string.alpha({ length: 3, casing: 'upper' }),\n   *   })\n   * );\n   *\n   * // Create a builder that doesn't auto-insert (useful for nested inserts)\n   * const addressBuilder = KyselyFactory.createBuilder<DB, 'addresses'>('addresses',\n   *   ({ attrs }) => ({\n   *     street: '123 Main St',\n   *     city: 'Anytown',\n   *     ...attrs\n   *   }),\n   *   false // Don't auto-insert\n   * );\n   * ```\n   */\n  static createBuilder<\n    DB,\n    TableName extends keyof DB & string,\n    Attrs extends Partial<Insertable<DB[TableName]>> = Partial<\n      Insertable<DB[TableName]>\n    >,\n    Factory = any,\n    Result = Selectable<DB[TableName]>,\n  >(\n    table: TableName,\n    defaults?: (context: {\n      attrs: Attrs;\n      factory: Factory;\n      db: Kysely<DB>;\n      faker: FakerFactory;\n    }) =>\n      | Partial<Insertable<DB[TableName]>>\n      | Promise<Partial<Insertable<DB[TableName]>>>,\n    autoInsert?: boolean,\n  ): (\n    attrs: Attrs,\n    factory: Factory,\n    db: Kysely<DB>,\n    faker: FakerFactory,\n  ) => Promise<Result> {\n    return async (\n      attrs: Attrs,\n      factory: Factory,\n      db: Kysely<DB>,\n      fakerInstance: FakerFactory,\n    ) => {\n      // Start with attributes\n      let data: Partial<Insertable<DB[TableName]>> = { ...attrs };\n\n      // Apply defaults\n      if (defaults) {\n        const defaultValues = await defaults({\n          attrs,\n          factory,\n          db,\n          faker: fakerInstance,\n        });\n        data = { ...defaultValues, ...data };\n      }\n\n      // Handle insertion based on autoInsert flag\n      if (autoInsert !== false) {\n        // Auto insert is enabled by default\n        const result = await db\n          .insertInto(table)\n          .values(data as Insertable<DB[TableName]>)\n          .returningAll()\n          .executeTakeFirst();\n\n        if (!result) {\n          throw new Error(`Failed to insert into ${table}`);\n        }\n\n        return result as Result;\n      } else {\n        // Return object for factory to handle insertion\n        return { table, data } as any;\n      }\n    };\n  }\n\n  /**\n   * Inserts a single record into the database using the specified builder.\n   * The builder function is responsible for generating the record data with defaults\n   * and the factory handles the actual database insertion.\n   *\n   * @template K - The builder name (must be a key of Builders)\n   * @param builderName - The name of the builder to use\n   * @param attrs - Optional attributes to override builder defaults\n   * @returns A promise resolving to the inserted record\n   * @throws Error if the specified builder doesn't exist\n   *\n   * @example\n   * ```typescript\n   * // Insert with defaults\n   * const user = await factory.insert('user');\n   *\n   * // Insert with overrides\n   * const adminUser = await factory.insert('user', {\n   *   email: 'admin@example.com',\n   *   role: 'admin'\n   * });\n   *\n   * // Use the inserted record\n   * const post = await factory.insert('post', {\n   *   userId: user.id,\n   *   title: 'My First Post'\n   * });\n   * ```\n   */\n  async insert<K extends keyof Builders>(\n    builderName: K,\n    attrs?: Parameters<Builders[K]>[0],\n  ): Promise<Awaited<ReturnType<Builders[K]>>> {\n    if (!(builderName in this.builders)) {\n      throw new Error(\n        `Factory \"${\n          builderName as string\n        }\" does not exist. Make sure it is correct and registered in src/test/setup.ts`,\n      );\n    }\n\n    const result = await this.builders[builderName](\n      attrs || {},\n      this,\n      this.db,\n      faker,\n    );\n\n    // For Kysely, we expect the builder to return an object with table and data properties\n    // or to handle the insertion itself and return the inserted record\n    if (\n      result &&\n      typeof result === 'object' &&\n      'table' in result &&\n      'data' in result\n    ) {\n      // If the builder returns {table: string, data: object}, we insert it\n      const inserted = await this.db\n        .insertInto(result.table)\n        .values(result.data)\n        .returningAll()\n        .executeTakeFirst();\n\n      return inserted as any;\n    }\n\n    // Otherwise, assume the builder handled the insertion itself\n    return result;\n  }\n\n  /**\n   * Inserts multiple records into the database using the specified builder.\n   * Supports both static attributes and dynamic attribute generation via a function.\n   *\n   * @template K - The builder name (must be a key of Builders)\n   * @param count - The number of records to insert\n   * @param builderName - The name of the builder to use\n   * @param attrs - Static attributes or a function that generates attributes for each record\n   * @returns A promise resolving to an array of inserted records\n   * @throws Error if the specified builder doesn't exist\n   *\n   * @example\n   * ```typescript\n   * // Insert multiple with same attributes\n   * const users = await factory.insertMany(5, 'user', { role: 'member' });\n   *\n   * // Insert multiple with dynamic attributes\n   * const posts = await factory.insertMany(10, 'post', (idx, faker) => ({\n   *   title: `Post ${idx + 1}`,\n   *   content: faker.lorem.paragraph(),\n   *   publishedAt: faker.date.past()\n   * }));\n   *\n   * // Create users with sequential emails\n   * const admins = await factory.insertMany(3, 'user', (idx) => ({\n   *   email: `admin${idx + 1}@example.com`,\n   *   role: 'admin'\n   * }));\n   * ```\n   */\n  // Method overloads for better type inference\n  async insertMany<K extends keyof Builders>(\n    count: number,\n    builderName: K,\n    attrs?: Parameters<Builders[K]>[0],\n  ): Promise<Awaited<ReturnType<Builders[K]>>[]>;\n  async insertMany<K extends keyof Builders>(\n    count: number,\n    builderName: K,\n    attrs: (\n      idx: number,\n      faker: FakerFactory,\n    ) => Parameters<Builders[K]>[0] | Promise<Parameters<Builders[K]>[0]>,\n  ): Promise<Awaited<ReturnType<Builders[K]>>[]>;\n  async insertMany<K extends keyof Builders>(\n    count: number,\n    builderName: K,\n    attrs?: any,\n  ): Promise<Awaited<ReturnType<Builders[K]>>[]> {\n    if (!(builderName in this.builders)) {\n      throw new Error(\n        `Builder \"${\n          builderName as string\n        }\" is not registered in this factory. Make sure it is correct and registered in src/test/setup.ts`,\n      );\n    }\n\n    const promises: Promise<any>[] = [];\n\n    for (let i = 0; i < count; i++) {\n      const newAttrs =\n        typeof attrs === 'function' ? await attrs(i, faker) : attrs;\n      promises.push(this.insert(builderName, newAttrs));\n    }\n\n    return Promise.all(promises);\n  }\n\n  /**\n   * Executes a seed function to create complex test scenarios with multiple related records.\n   * Seeds are useful for setting up complete test environments with realistic data relationships.\n   *\n   * @template K - The seed name (must be a key of Seeds)\n   * @param seedName - The name of the seed to execute\n   * @param attrs - Optional configuration attributes for the seed\n   * @returns The result of the seed function (typically the primary record created)\n   * @throws Error if the specified seed doesn't exist\n   *\n   * @example\n   * ```typescript\n   * // Execute a simple seed\n   * const user = await factory.seed('userWithProfile');\n   *\n   * // Execute a seed with configuration\n   * const author = await factory.seed('authorWithBooks', {\n   *   bookCount: 5,\n   *   includeReviews: true\n   * });\n   *\n   * // Use seed result in tests\n   * const company = await factory.seed('companyWithDepartments', {\n   *   departmentCount: 3,\n   *   employeesPerDepartment: 10\n   * });\n   * expect(company.departments).toHaveLength(3);\n   * ```\n   */\n  seed<K extends keyof Seeds>(\n    seedName: K,\n    attrs?: Parameters<Seeds[K]>[0],\n  ): ReturnType<Seeds[K]> {\n    if (!(seedName in this.seeds)) {\n      throw new Error(\n        `Seed \"${\n          seedName as string\n        }\" is not registered in this factory. Make sure it is correct and registered in src/test/setup.ts`,\n      );\n    }\n\n    return this.seeds[seedName](attrs || {}, this, this.db);\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+CA,IAAa,gBAAb,cAIUA,wBAAyB;;;;;;;;;CASjC,OAAO,WAAqCC,QAAoB;AAC9D,SAAO,wBAAQ,WAAW,OAAO;CAClC;;;;;;;;CASD,YACUC,UACAC,OACAC,IACR;AACA,SAAO;EAJC;EACA;EACA;CAGT;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAiDD,OAAO,cASLC,OACAC,UAQAC,YAMmB;AACnB,SAAO,OACLC,OACAC,SACAC,IACAC,kBACG;GAEH,IAAIC,OAA2C,EAAE,GAAG,MAAO;AAG3D,OAAI,UAAU;IACZ,MAAM,gBAAgB,MAAM,SAAS;KACnC;KACA;KACA;KACA,OAAO;IACR,EAAC;AACF,WAAO;KAAE,GAAG;KAAe,GAAG;IAAM;GACrC;AAGD,OAAI,eAAe,OAAO;IAExB,MAAM,SAAS,MAAM,GAClB,WAAW,MAAM,CACjB,OAAO,KAAkC,CACzC,cAAc,CACd,kBAAkB;AAErB,SAAK,OACH,OAAM,IAAI,OAAO,wBAAwB,MAAM;AAGjD,WAAO;GACR,MAEC,QAAO;IAAE;IAAO;GAAM;EAEzB;CACF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+BD,MAAM,OACJC,aACAC,OAC2C;AAC3C,QAAM,eAAe,KAAK,UACxB,OAAM,IAAI,OACP,WACC,YACD;EAIL,MAAM,SAAS,MAAM,KAAK,SAAS,aACjC,SAAS,CAAE,GACX,MACA,KAAK,IACLC,oBACD;AAID,MACE,iBACO,WAAW,YAClB,WAAW,UACX,UAAU,QACV;GAEA,MAAM,WAAW,MAAM,KAAK,GACzB,WAAW,OAAO,MAAM,CACxB,OAAO,OAAO,KAAK,CACnB,cAAc,CACd,kBAAkB;AAErB,UAAO;EACR;AAGD,SAAO;CACR;CA8CD,MAAM,WACJC,OACAH,aACAI,OAC6C;AAC7C,QAAM,eAAe,KAAK,UACxB,OAAM,IAAI,OACP,WACC,YACD;EAIL,MAAMC,WAA2B,CAAE;AAEnC,OAAK,IAAI,IAAI,GAAG,IAAI,OAAO,KAAK;GAC9B,MAAM,kBACG,UAAU,aAAa,MAAM,MAAM,GAAGH,oBAAM,GAAG;AACxD,YAAS,KAAK,KAAK,OAAO,aAAa,SAAS,CAAC;EAClD;AAED,SAAO,QAAQ,IAAI,SAAS;CAC7B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+BD,KACEI,UACAC,OACsB;AACtB,QAAM,YAAY,KAAK,OACrB,OAAM,IAAI,OACP,QACC,SACD;AAIL,SAAO,KAAK,MAAM,UAAU,SAAS,CAAE,GAAE,MAAM,KAAK,GAAG;CACxD;AACF"}

package/dist/ObjectionFactory-Eb04AOnv.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"ObjectionFactory-Eb04AOnv.cjs","names":["Factory","seedFn: Seed","ModelClass: TModel","defaults?: (context: {\n      attrs: Attrs;\n      factory: Factory;\n      db: Knex;\n      faker: FakerFactory;\n    }) =>\n      | Partial<InstanceType<TModel>>\n      | Promise<Partial<InstanceType<TModel>>>","autoInsert?: boolean","attrs: Attrs","factory: Factory","db: Knex","fakerInstance: FakerFactory","data: Partial<InstanceType<TModel>>","builders: Builders","seeds: Seeds","builderName: K","attrs?: Parameters<Builders[K]>[0]","faker","count: number","attrs?: any","records: any[]","record: any","seedName: K","attrs?: Parameters<Seeds[K]>[0]"],"sources":["../src/ObjectionFactory.ts"],"sourcesContent":["import type { Knex } from 'knex';\nimport type { Model } from 'objection';\nimport { Factory, type FactorySeed } from './Factory.ts';\nimport { type FakerFactory, faker } from './faker.ts';\n\n/**\n * Factory implementation for Objection.js ORM, providing test data creation utilities.\n * Extends the base Factory class with Objection.js-specific database operations.\n *\n * @template Builders - Record of builder functions for creating entities\n * @template Seeds - Record of seed functions for complex test scenarios\n *\n * @example\n * ```typescript\n * // Define your models with Objection.js\n * class User extends Model {\n *   static tableName = 'users';\n * }\n *\n * // Create builders\n * const builders = {\n *   user: ObjectionFactory.createBuilder(User, ({ attrs, faker }) => ({\n *     id: faker.string.uuid(),\n *     name: faker.person.fullName(),\n *     email: faker.internet.email(),\n *     ...attrs\n *   })),\n *   post: ObjectionFactory.createBuilder(Post, ({ attrs }) => ({\n *     title: 'Test Post',\n *     content: 'Test content',\n *     ...attrs\n *   })),\n * };\n *\n * // Create factory instance\n * const factory = new ObjectionFactory(builders, seeds, knex);\n *\n * // Use in tests\n * const user = await factory.insert('user', { name: 'John Doe' });\n * ```\n */\nexport class ObjectionFactory<\n  Builders extends Record<string, any>,\n  Seeds extends Record<string, any>,\n> extends Factory<Builders, Seeds> {\n  /**\n   * Creates a typed seed function with proper type inference.\n   * Inherits from the base Factory class implementation.\n   *\n   * @template Seed - The seed function type\n   * @param seedFn - The seed function to wrap\n   * @returns The same seed function with proper typing\n   */\n  static createSeed<Seed extends FactorySeed>(seedFn: Seed): Seed {\n    return Factory.createSeed(seedFn);\n  }\n\n  /**\n   * Creates a typed builder function for Objection.js models.\n   * This is a utility method that helps create builders with proper type inference.\n   *\n   * @template TModel - The Objection.js Model class type\n   * @template Attrs - The attributes type for the builder (defaults to Partial of model)\n   * @template Factory - The factory instance type\n   * @template Result - The result type (defaults to the model instance)\n   *\n   * @param ModelClass - The Objection.js Model class\n   * @param defaults - Optional function to provide default values (receives destructured context)\n   * @param autoInsert - Whether to automatically insert the record (default: true)\n   * @returns A builder function that creates and optionally inserts records\n   *\n   * @example\n   * ```typescript\n   * // Create a simple builder with defaults - destructure only what you need\n   * const userBuilder = ObjectionFactory.createBuilder(User,\n   *   ({ attrs, faker }) => ({\n   *     id: faker.string.uuid(),\n   *     name: faker.person.fullName(),\n   *     email: faker.internet.email(),\n   *     createdAt: new Date(),\n   *     ...attrs\n   *   })\n   * );\n   *\n   * // Only need faker? Just destructure that\n   * const leaveTypeBuilder = ObjectionFactory.createBuilder(LeaveType,\n   *   ({ faker }) => ({\n   *     name: faker.helpers.arrayElement(['Annual', 'Sick', 'Maternity']),\n   *     code: faker.string.alpha({ length: 3, casing: 'upper' }),\n   *   })\n   * );\n   *\n   * // Create a builder that doesn't auto-insert (useful for nested inserts)\n   * const addressBuilder = ObjectionFactory.createBuilder(Address,\n   *   ({ attrs }) => ({\n   *     street: '123 Main St',\n   *     city: 'Anytown',\n   *     ...attrs\n   *   }),\n   *   false // Don't auto-insert\n   * );\n   *\n   * // Use with relations\n   * const postBuilder = ObjectionFactory.createBuilder(Post,\n   *   async ({ attrs, factory, faker }) => ({\n   *     title: faker.lorem.sentence(),\n   *     content: faker.lorem.paragraphs(),\n   *     authorId: attrs.authorId || (await factory.insert('user')).id,\n   *     ...attrs\n   *   })\n   * );\n   * ```\n   */\n  static createBuilder<\n    TModel extends typeof Model,\n    Attrs extends Partial<InstanceType<TModel>> = Partial<InstanceType<TModel>>,\n    Factory = any,\n    Result = InstanceType<TModel>,\n  >(\n    ModelClass: TModel,\n    defaults?: (context: {\n      attrs: Attrs;\n      factory: Factory;\n      db: Knex;\n      faker: FakerFactory;\n    }) =>\n      | Partial<InstanceType<TModel>>\n      | Promise<Partial<InstanceType<TModel>>>,\n    autoInsert?: boolean,\n  ): (\n    attrs: Attrs,\n    factory: Factory,\n    db: Knex,\n    faker: FakerFactory,\n  ) => Promise<Result> {\n    return async (\n      attrs: Attrs,\n      factory: Factory,\n      db: Knex,\n      fakerInstance: FakerFactory,\n    ) => {\n      // Start with attributes\n      let data: Partial<InstanceType<TModel>> = { ...attrs };\n\n      // Apply defaults\n      if (defaults) {\n        const defaultValues = await defaults({\n          attrs,\n          factory,\n          db,\n          faker: fakerInstance,\n        });\n        data = { ...defaultValues, ...data };\n      }\n\n      // Create model instance\n      const model = ModelClass.fromJson(data) as InstanceType<TModel>;\n\n      // Handle insertion based on autoInsert flag\n      if (autoInsert !== false) {\n        // Auto insert is enabled by default\n        // Extract only defined values for insertion\n        const insertData = Object.entries(model).reduce((acc, [key, value]) => {\n          if (value !== undefined && key !== 'id') {\n            acc[key] = value;\n          }\n          return acc;\n        }, {} as any);\n\n        // Use static query method to insert data directly\n        // @ts-ignore\n        const result = await ModelClass.query(db).insert(insertData);\n        return result as Result;\n      } else {\n        // Return model for factory to handle insertion\n        return model as Result;\n      }\n    };\n  }\n\n  /**\n   * Creates a new ObjectionFactory instance.\n   *\n   * @param builders - Record of builder functions for creating individual entities\n   * @param seeds - Record of seed functions for creating complex test scenarios\n   * @param db - Knex database connection instance\n   */\n  constructor(\n    private builders: Builders,\n    private seeds: Seeds,\n    private db: Knex,\n  ) {\n    super();\n  }\n\n  /**\n   * Inserts a single record into the database using the specified builder.\n   * Uses Objection.js's insertGraph method to handle nested relations.\n   *\n   * @template K - The builder name (must be a key of Builders)\n   * @param builderName - The name of the builder to use\n   * @param attrs - Optional attributes to override builder defaults\n   * @returns A promise resolving to the inserted record with all relations\n   * @throws Error if the specified builder doesn't exist\n   *\n   * @example\n   * ```typescript\n   * // Insert with defaults\n   * const user = await factory.insert('user');\n   *\n   * // Insert with overrides\n   * const adminUser = await factory.insert('user', {\n   *   email: 'admin@example.com',\n   *   role: 'admin'\n   * });\n   *\n   * // Insert with nested relations\n   * const userWithProfile = await factory.insert('user', {\n   *   name: 'John Doe',\n   *   profile: {\n   *     bio: 'Software Developer',\n   *     avatar: 'avatar.jpg'\n   *   }\n   * });\n   * ```\n   */\n  async insert<K extends keyof Builders>(\n    builderName: K,\n    attrs?: Parameters<Builders[K]>[0],\n  ): Promise<Awaited<ReturnType<Builders[K]>>> {\n    if (!(builderName in this.builders)) {\n      throw new Error(\n        `Factory \"${\n          builderName as string\n        }\" does not exist. Make sure it is correct and registered in src/test/setup.ts`,\n      );\n    }\n\n    const result = await this.builders[builderName](\n      attrs || {},\n      this,\n      this.db,\n      faker,\n    );\n\n    // If the builder returns a model instance, insert it\n    if (result && typeof result.$query === 'function') {\n      // Extract data from model, excluding undefined values and id\n      const insertData = Object.entries(result).reduce((acc, [key, value]) => {\n        if (value !== undefined && key !== 'id') {\n          acc[key] = value;\n        }\n        return acc;\n      }, {} as any);\n\n      // Use the model's constructor to get the query builder\n      return await result.constructor.query(this.db).insert(insertData);\n    }\n\n    // Otherwise, assume the builder handled insertion itself\n    return result;\n  }\n  /**\n   * Inserts multiple records into the database using the specified builder.\n   * Supports both static attributes and dynamic attribute generation via a function.\n   *\n   * @param count - The number of records to insert\n   * @param builderName - The name of the builder to use\n   * @param attrs - Static attributes or a function that generates attributes for each record\n   * @returns A promise resolving to an array of inserted records\n   * @throws Error if the specified builder doesn't exist\n   *\n   * @example\n   * ```typescript\n   * // Insert multiple with same attributes\n   * const users = await factory.insertMany(5, 'user', { role: 'member' });\n   *\n   * // Insert multiple with dynamic attributes\n   * const posts = await factory.insertMany(10, 'post', (idx) => ({\n   *   title: `Post ${idx + 1}`,\n   *   content: `Content for post ${idx + 1}`,\n   *   publishedAt: new Date()\n   * }));\n   *\n   * // Create users with sequential emails\n   * const admins = await factory.insertMany(3, 'user', (idx) => ({\n   *   email: `admin${idx + 1}@example.com`,\n   *   role: 'admin'\n   * }));\n   * ```\n   */\n  // Method overloads for better type inference\n  async insertMany<K extends keyof Builders>(\n    count: number,\n    builderName: K,\n    attrs?: Parameters<Builders[K]>[0],\n  ): Promise<Awaited<ReturnType<Builders[K]>>[]>;\n  async insertMany<K extends keyof Builders>(\n    count: number,\n    builderName: K,\n    attrs: (idx: number, faker: FakerFactory) => Parameters<Builders[K]>[0],\n  ): Promise<Awaited<ReturnType<Builders[K]>>[]>;\n  async insertMany<K extends keyof Builders>(\n    count: number,\n    builderName: K,\n    attrs?: any,\n  ): Promise<Awaited<ReturnType<Builders[K]>>[]> {\n    if (!(builderName in this.builders)) {\n      throw new Error(\n        `Builder \"${\n          builderName as string\n        }\" is not registered in this factory. Make sure it is correct and registered in src/test/setup.ts`,\n      );\n    }\n\n    const records: any[] = [];\n    for (let i = 0; i < count; i++) {\n      const newAttrs =\n        typeof attrs === 'function' ? await (attrs as any)(i, faker) : attrs;\n\n      records.push(\n        this.builders[builderName](newAttrs, this, this.db, faker).then(\n          (record: any) => {\n            // If the builder returns a model instance, insert it\n            if (record && typeof record.$query === 'function') {\n              // Extract data from model, excluding undefined values and id\n              const insertData = Object.entries(record).reduce(\n                (acc, [key, value]) => {\n                  if (value !== undefined && key !== 'id') {\n                    acc[key] = value;\n                  }\n                  return acc;\n                },\n                {} as any,\n              );\n\n              // Use the model's constructor to get the query builder\n              return record.constructor.query(this.db).insert(insertData);\n            }\n            // Otherwise, assume the builder handled insertion itself\n            return record;\n          },\n        ),\n      );\n    }\n\n    return Promise.all(records);\n  }\n  /**\n   * Executes a seed function to create complex test scenarios with multiple related records.\n   * Seeds are useful for setting up complete test environments with realistic data relationships.\n   *\n   * @template K - The seed name (must be a key of Seeds)\n   * @param seedName - The name of the seed to execute\n   * @param attrs - Optional configuration attributes for the seed\n   * @returns The result of the seed function (typically the primary record created)\n   * @throws Error if the specified seed doesn't exist\n   *\n   * @example\n   * ```typescript\n   * // Execute a simple seed\n   * const user = await factory.seed('userWithProfile');\n   *\n   * // Execute a seed with configuration\n   * const author = await factory.seed('authorWithBooks', {\n   *   bookCount: 5,\n   *   includeReviews: true\n   * });\n   *\n   * // Use seed result in tests with Objection.js relations\n   * const company = await factory.seed('companyWithDepartments', {\n   *   departmentCount: 3,\n   *   employeesPerDepartment: 10\n   * });\n   *\n   * // Access eager loaded relations\n   * const companyWithRelations = await Company.query()\n   *   .findById(company.id)\n   *   .withGraphFetched('[departments.employees]');\n   * ```\n   */\n  seed<K extends keyof Seeds>(\n    seedName: K,\n    attrs?: Parameters<Seeds[K]>[0],\n  ): ReturnType<Seeds[K]> {\n    if (!(seedName in this.seeds)) {\n      throw new Error(\n        `Seed \"${\n          seedName as string\n        }\" is not registered in this factory. Make sure it is correct and registered in src/test/setup.ts`,\n      );\n    }\n\n    return this.seeds[seedName](attrs || {}, this, this.db);\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAyCA,IAAa,mBAAb,cAGUA,wBAAyB;;;;;;;;;CASjC,OAAO,WAAqCC,QAAoB;AAC9D,SAAO,wBAAQ,WAAW,OAAO;CAClC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA0DD,OAAO,cAMLC,YACAC,UAQAC,YAMmB;AACnB,SAAO,OACLC,OACAC,SACAC,IACAC,kBACG;GAEH,IAAIC,OAAsC,EAAE,GAAG,MAAO;AAGtD,OAAI,UAAU;IACZ,MAAM,gBAAgB,MAAM,SAAS;KACnC;KACA;KACA;KACA,OAAO;IACR,EAAC;AACF,WAAO;KAAE,GAAG;KAAe,GAAG;IAAM;GACrC;GAGD,MAAM,QAAQ,WAAW,SAAS,KAAK;AAGvC,OAAI,eAAe,OAAO;IAGxB,MAAM,aAAa,OAAO,QAAQ,MAAM,CAAC,OAAO,CAAC,KAAK,CAAC,KAAK,MAAM,KAAK;AACrE,SAAI,oBAAuB,QAAQ,KACjC,KAAI,OAAO;AAEb,YAAO;IACR,GAAE,CAAE,EAAQ;IAIb,MAAM,SAAS,MAAM,WAAW,MAAM,GAAG,CAAC,OAAO,WAAW;AAC5D,WAAO;GACR,MAEC,QAAO;EAEV;CACF;;;;;;;;CASD,YACUC,UACAC,OACAJ,IACR;AACA,SAAO;EAJC;EACA;EACA;CAGT;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAiCD,MAAM,OACJK,aACAC,OAC2C;AAC3C,QAAM,eAAe,KAAK,UACxB,OAAM,IAAI,OACP,WACC,YACD;EAIL,MAAM,SAAS,MAAM,KAAK,SAAS,aACjC,SAAS,CAAE,GACX,MACA,KAAK,IACLC,oBACD;AAGD,MAAI,iBAAiB,OAAO,WAAW,YAAY;GAEjD,MAAM,aAAa,OAAO,QAAQ,OAAO,CAAC,OAAO,CAAC,KAAK,CAAC,KAAK,MAAM,KAAK;AACtE,QAAI,oBAAuB,QAAQ,KACjC,KAAI,OAAO;AAEb,WAAO;GACR,GAAE,CAAE,EAAQ;AAGb,UAAO,MAAM,OAAO,YAAY,MAAM,KAAK,GAAG,CAAC,OAAO,WAAW;EAClE;AAGD,SAAO;CACR;CAyCD,MAAM,WACJC,OACAH,aACAI,OAC6C;AAC7C,QAAM,eAAe,KAAK,UACxB,OAAM,IAAI,OACP,WACC,YACD;EAIL,MAAMC,UAAiB,CAAE;AACzB,OAAK,IAAI,IAAI,GAAG,IAAI,OAAO,KAAK;GAC9B,MAAM,kBACG,UAAU,aAAa,MAAM,AAAC,MAAc,GAAGH,oBAAM,GAAG;AAEjE,WAAQ,KACN,KAAK,SAAS,aAAa,UAAU,MAAM,KAAK,IAAIA,oBAAM,CAAC,KACzD,CAACI,WAAgB;AAEf,QAAI,iBAAiB,OAAO,WAAW,YAAY;KAEjD,MAAM,aAAa,OAAO,QAAQ,OAAO,CAAC,OACxC,CAAC,KAAK,CAAC,KAAK,MAAM,KAAK;AACrB,UAAI,oBAAuB,QAAQ,KACjC,KAAI,OAAO;AAEb,aAAO;KACR,GACD,CAAE,EACH;AAGD,YAAO,OAAO,YAAY,MAAM,KAAK,GAAG,CAAC,OAAO,WAAW;IAC5D;AAED,WAAO;GACR,EACF,CACF;EACF;AAED,SAAO,QAAQ,IAAI,QAAQ;CAC5B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkCD,KACEC,UACAC,OACsB;AACtB,QAAM,YAAY,KAAK,OACrB,OAAM,IAAI,OACP,QACC,SACD;AAIL,SAAO,KAAK,MAAM,UAAU,SAAS,CAAE,GAAE,MAAM,KAAK,GAAG;CACxD;AACF"}

package/dist/ObjectionFactory-zf2fLKrL.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"ObjectionFactory-zf2fLKrL.mjs","names":["seedFn: Seed","ModelClass: TModel","defaults?: (context: {\n      attrs: Attrs;\n      factory: Factory;\n      db: Knex;\n      faker: FakerFactory;\n    }) =>\n      | Partial<InstanceType<TModel>>\n      | Promise<Partial<InstanceType<TModel>>>","autoInsert?: boolean","attrs: Attrs","factory: Factory","db: Knex","fakerInstance: FakerFactory","data: Partial<InstanceType<TModel>>","builders: Builders","seeds: Seeds","builderName: K","attrs?: Parameters<Builders[K]>[0]","count: number","attrs?: any","records: any[]","record: any","seedName: K","attrs?: Parameters<Seeds[K]>[0]"],"sources":["../src/ObjectionFactory.ts"],"sourcesContent":["import type { Knex } from 'knex';\nimport type { Model } from 'objection';\nimport { Factory, type FactorySeed } from './Factory.ts';\nimport { type FakerFactory, faker } from './faker.ts';\n\n/**\n * Factory implementation for Objection.js ORM, providing test data creation utilities.\n * Extends the base Factory class with Objection.js-specific database operations.\n *\n * @template Builders - Record of builder functions for creating entities\n * @template Seeds - Record of seed functions for complex test scenarios\n *\n * @example\n * ```typescript\n * // Define your models with Objection.js\n * class User extends Model {\n *   static tableName = 'users';\n * }\n *\n * // Create builders\n * const builders = {\n *   user: ObjectionFactory.createBuilder(User, ({ attrs, faker }) => ({\n *     id: faker.string.uuid(),\n *     name: faker.person.fullName(),\n *     email: faker.internet.email(),\n *     ...attrs\n *   })),\n *   post: ObjectionFactory.createBuilder(Post, ({ attrs }) => ({\n *     title: 'Test Post',\n *     content: 'Test content',\n *     ...attrs\n *   })),\n * };\n *\n * // Create factory instance\n * const factory = new ObjectionFactory(builders, seeds, knex);\n *\n * // Use in tests\n * const user = await factory.insert('user', { name: 'John Doe' });\n * ```\n */\nexport class ObjectionFactory<\n  Builders extends Record<string, any>,\n  Seeds extends Record<string, any>,\n> extends Factory<Builders, Seeds> {\n  /**\n   * Creates a typed seed function with proper type inference.\n   * Inherits from the base Factory class implementation.\n   *\n   * @template Seed - The seed function type\n   * @param seedFn - The seed function to wrap\n   * @returns The same seed function with proper typing\n   */\n  static createSeed<Seed extends FactorySeed>(seedFn: Seed): Seed {\n    return Factory.createSeed(seedFn);\n  }\n\n  /**\n   * Creates a typed builder function for Objection.js models.\n   * This is a utility method that helps create builders with proper type inference.\n   *\n   * @template TModel - The Objection.js Model class type\n   * @template Attrs - The attributes type for the builder (defaults to Partial of model)\n   * @template Factory - The factory instance type\n   * @template Result - The result type (defaults to the model instance)\n   *\n   * @param ModelClass - The Objection.js Model class\n   * @param defaults - Optional function to provide default values (receives destructured context)\n   * @param autoInsert - Whether to automatically insert the record (default: true)\n   * @returns A builder function that creates and optionally inserts records\n   *\n   * @example\n   * ```typescript\n   * // Create a simple builder with defaults - destructure only what you need\n   * const userBuilder = ObjectionFactory.createBuilder(User,\n   *   ({ attrs, faker }) => ({\n   *     id: faker.string.uuid(),\n   *     name: faker.person.fullName(),\n   *     email: faker.internet.email(),\n   *     createdAt: new Date(),\n   *     ...attrs\n   *   })\n   * );\n   *\n   * // Only need faker? Just destructure that\n   * const leaveTypeBuilder = ObjectionFactory.createBuilder(LeaveType,\n   *   ({ faker }) => ({\n   *     name: faker.helpers.arrayElement(['Annual', 'Sick', 'Maternity']),\n   *     code: faker.string.alpha({ length: 3, casing: 'upper' }),\n   *   })\n   * );\n   *\n   * // Create a builder that doesn't auto-insert (useful for nested inserts)\n   * const addressBuilder = ObjectionFactory.createBuilder(Address,\n   *   ({ attrs }) => ({\n   *     street: '123 Main St',\n   *     city: 'Anytown',\n   *     ...attrs\n   *   }),\n   *   false // Don't auto-insert\n   * );\n   *\n   * // Use with relations\n   * const postBuilder = ObjectionFactory.createBuilder(Post,\n   *   async ({ attrs, factory, faker }) => ({\n   *     title: faker.lorem.sentence(),\n   *     content: faker.lorem.paragraphs(),\n   *     authorId: attrs.authorId || (await factory.insert('user')).id,\n   *     ...attrs\n   *   })\n   * );\n   * ```\n   */\n  static createBuilder<\n    TModel extends typeof Model,\n    Attrs extends Partial<InstanceType<TModel>> = Partial<InstanceType<TModel>>,\n    Factory = any,\n    Result = InstanceType<TModel>,\n  >(\n    ModelClass: TModel,\n    defaults?: (context: {\n      attrs: Attrs;\n      factory: Factory;\n      db: Knex;\n      faker: FakerFactory;\n    }) =>\n      | Partial<InstanceType<TModel>>\n      | Promise<Partial<InstanceType<TModel>>>,\n    autoInsert?: boolean,\n  ): (\n    attrs: Attrs,\n    factory: Factory,\n    db: Knex,\n    faker: FakerFactory,\n  ) => Promise<Result> {\n    return async (\n      attrs: Attrs,\n      factory: Factory,\n      db: Knex,\n      fakerInstance: FakerFactory,\n    ) => {\n      // Start with attributes\n      let data: Partial<InstanceType<TModel>> = { ...attrs };\n\n      // Apply defaults\n      if (defaults) {\n        const defaultValues = await defaults({\n          attrs,\n          factory,\n          db,\n          faker: fakerInstance,\n        });\n        data = { ...defaultValues, ...data };\n      }\n\n      // Create model instance\n      const model = ModelClass.fromJson(data) as InstanceType<TModel>;\n\n      // Handle insertion based on autoInsert flag\n      if (autoInsert !== false) {\n        // Auto insert is enabled by default\n        // Extract only defined values for insertion\n        const insertData = Object.entries(model).reduce((acc, [key, value]) => {\n          if (value !== undefined && key !== 'id') {\n            acc[key] = value;\n          }\n          return acc;\n        }, {} as any);\n\n        // Use static query method to insert data directly\n        // @ts-ignore\n        const result = await ModelClass.query(db).insert(insertData);\n        return result as Result;\n      } else {\n        // Return model for factory to handle insertion\n        return model as Result;\n      }\n    };\n  }\n\n  /**\n   * Creates a new ObjectionFactory instance.\n   *\n   * @param builders - Record of builder functions for creating individual entities\n   * @param seeds - Record of seed functions for creating complex test scenarios\n   * @param db - Knex database connection instance\n   */\n  constructor(\n    private builders: Builders,\n    private seeds: Seeds,\n    private db: Knex,\n  ) {\n    super();\n  }\n\n  /**\n   * Inserts a single record into the database using the specified builder.\n   * Uses Objection.js's insertGraph method to handle nested relations.\n   *\n   * @template K - The builder name (must be a key of Builders)\n   * @param builderName - The name of the builder to use\n   * @param attrs - Optional attributes to override builder defaults\n   * @returns A promise resolving to the inserted record with all relations\n   * @throws Error if the specified builder doesn't exist\n   *\n   * @example\n   * ```typescript\n   * // Insert with defaults\n   * const user = await factory.insert('user');\n   *\n   * // Insert with overrides\n   * const adminUser = await factory.insert('user', {\n   *   email: 'admin@example.com',\n   *   role: 'admin'\n   * });\n   *\n   * // Insert with nested relations\n   * const userWithProfile = await factory.insert('user', {\n   *   name: 'John Doe',\n   *   profile: {\n   *     bio: 'Software Developer',\n   *     avatar: 'avatar.jpg'\n   *   }\n   * });\n   * ```\n   */\n  async insert<K extends keyof Builders>(\n    builderName: K,\n    attrs?: Parameters<Builders[K]>[0],\n  ): Promise<Awaited<ReturnType<Builders[K]>>> {\n    if (!(builderName in this.builders)) {\n      throw new Error(\n        `Factory \"${\n          builderName as string\n        }\" does not exist. Make sure it is correct and registered in src/test/setup.ts`,\n      );\n    }\n\n    const result = await this.builders[builderName](\n      attrs || {},\n      this,\n      this.db,\n      faker,\n    );\n\n    // If the builder returns a model instance, insert it\n    if (result && typeof result.$query === 'function') {\n      // Extract data from model, excluding undefined values and id\n      const insertData = Object.entries(result).reduce((acc, [key, value]) => {\n        if (value !== undefined && key !== 'id') {\n          acc[key] = value;\n        }\n        return acc;\n      }, {} as any);\n\n      // Use the model's constructor to get the query builder\n      return await result.constructor.query(this.db).insert(insertData);\n    }\n\n    // Otherwise, assume the builder handled insertion itself\n    return result;\n  }\n  /**\n   * Inserts multiple records into the database using the specified builder.\n   * Supports both static attributes and dynamic attribute generation via a function.\n   *\n   * @param count - The number of records to insert\n   * @param builderName - The name of the builder to use\n   * @param attrs - Static attributes or a function that generates attributes for each record\n   * @returns A promise resolving to an array of inserted records\n   * @throws Error if the specified builder doesn't exist\n   *\n   * @example\n   * ```typescript\n   * // Insert multiple with same attributes\n   * const users = await factory.insertMany(5, 'user', { role: 'member' });\n   *\n   * // Insert multiple with dynamic attributes\n   * const posts = await factory.insertMany(10, 'post', (idx) => ({\n   *   title: `Post ${idx + 1}`,\n   *   content: `Content for post ${idx + 1}`,\n   *   publishedAt: new Date()\n   * }));\n   *\n   * // Create users with sequential emails\n   * const admins = await factory.insertMany(3, 'user', (idx) => ({\n   *   email: `admin${idx + 1}@example.com`,\n   *   role: 'admin'\n   * }));\n   * ```\n   */\n  // Method overloads for better type inference\n  async insertMany<K extends keyof Builders>(\n    count: number,\n    builderName: K,\n    attrs?: Parameters<Builders[K]>[0],\n  ): Promise<Awaited<ReturnType<Builders[K]>>[]>;\n  async insertMany<K extends keyof Builders>(\n    count: number,\n    builderName: K,\n    attrs: (idx: number, faker: FakerFactory) => Parameters<Builders[K]>[0],\n  ): Promise<Awaited<ReturnType<Builders[K]>>[]>;\n  async insertMany<K extends keyof Builders>(\n    count: number,\n    builderName: K,\n    attrs?: any,\n  ): Promise<Awaited<ReturnType<Builders[K]>>[]> {\n    if (!(builderName in this.builders)) {\n      throw new Error(\n        `Builder \"${\n          builderName as string\n        }\" is not registered in this factory. Make sure it is correct and registered in src/test/setup.ts`,\n      );\n    }\n\n    const records: any[] = [];\n    for (let i = 0; i < count; i++) {\n      const newAttrs =\n        typeof attrs === 'function' ? await (attrs as any)(i, faker) : attrs;\n\n      records.push(\n        this.builders[builderName](newAttrs, this, this.db, faker).then(\n          (record: any) => {\n            // If the builder returns a model instance, insert it\n            if (record && typeof record.$query === 'function') {\n              // Extract data from model, excluding undefined values and id\n              const insertData = Object.entries(record).reduce(\n                (acc, [key, value]) => {\n                  if (value !== undefined && key !== 'id') {\n                    acc[key] = value;\n                  }\n                  return acc;\n                },\n                {} as any,\n              );\n\n              // Use the model's constructor to get the query builder\n              return record.constructor.query(this.db).insert(insertData);\n            }\n            // Otherwise, assume the builder handled insertion itself\n            return record;\n          },\n        ),\n      );\n    }\n\n    return Promise.all(records);\n  }\n  /**\n   * Executes a seed function to create complex test scenarios with multiple related records.\n   * Seeds are useful for setting up complete test environments with realistic data relationships.\n   *\n   * @template K - The seed name (must be a key of Seeds)\n   * @param seedName - The name of the seed to execute\n   * @param attrs - Optional configuration attributes for the seed\n   * @returns The result of the seed function (typically the primary record created)\n   * @throws Error if the specified seed doesn't exist\n   *\n   * @example\n   * ```typescript\n   * // Execute a simple seed\n   * const user = await factory.seed('userWithProfile');\n   *\n   * // Execute a seed with configuration\n   * const author = await factory.seed('authorWithBooks', {\n   *   bookCount: 5,\n   *   includeReviews: true\n   * });\n   *\n   * // Use seed result in tests with Objection.js relations\n   * const company = await factory.seed('companyWithDepartments', {\n   *   departmentCount: 3,\n   *   employeesPerDepartment: 10\n   * });\n   *\n   * // Access eager loaded relations\n   * const companyWithRelations = await Company.query()\n   *   .findById(company.id)\n   *   .withGraphFetched('[departments.employees]');\n   * ```\n   */\n  seed<K extends keyof Seeds>(\n    seedName: K,\n    attrs?: Parameters<Seeds[K]>[0],\n  ): ReturnType<Seeds[K]> {\n    if (!(seedName in this.seeds)) {\n      throw new Error(\n        `Seed \"${\n          seedName as string\n        }\" is not registered in this factory. Make sure it is correct and registered in src/test/setup.ts`,\n      );\n    }\n\n    return this.seeds[seedName](attrs || {}, this, this.db);\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAyCA,IAAa,mBAAb,cAGU,QAAyB;;;;;;;;;CASjC,OAAO,WAAqCA,QAAoB;AAC9D,SAAO,QAAQ,WAAW,OAAO;CAClC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA0DD,OAAO,cAMLC,YACAC,UAQAC,YAMmB;AACnB,SAAO,OACLC,OACAC,SACAC,IACAC,kBACG;GAEH,IAAIC,OAAsC,EAAE,GAAG,MAAO;AAGtD,OAAI,UAAU;IACZ,MAAM,gBAAgB,MAAM,SAAS;KACnC;KACA;KACA;KACA,OAAO;IACR,EAAC;AACF,WAAO;KAAE,GAAG;KAAe,GAAG;IAAM;GACrC;GAGD,MAAM,QAAQ,WAAW,SAAS,KAAK;AAGvC,OAAI,eAAe,OAAO;IAGxB,MAAM,aAAa,OAAO,QAAQ,MAAM,CAAC,OAAO,CAAC,KAAK,CAAC,KAAK,MAAM,KAAK;AACrE,SAAI,oBAAuB,QAAQ,KACjC,KAAI,OAAO;AAEb,YAAO;IACR,GAAE,CAAE,EAAQ;IAIb,MAAM,SAAS,MAAM,WAAW,MAAM,GAAG,CAAC,OAAO,WAAW;AAC5D,WAAO;GACR,MAEC,QAAO;EAEV;CACF;;;;;;;;CASD,YACUC,UACAC,OACAJ,IACR;AACA,SAAO;EAJC;EACA;EACA;CAGT;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAiCD,MAAM,OACJK,aACAC,OAC2C;AAC3C,QAAM,eAAe,KAAK,UACxB,OAAM,IAAI,OACP,WACC,YACD;EAIL,MAAM,SAAS,MAAM,KAAK,SAAS,aACjC,SAAS,CAAE,GACX,MACA,KAAK,IACL,MACD;AAGD,MAAI,iBAAiB,OAAO,WAAW,YAAY;GAEjD,MAAM,aAAa,OAAO,QAAQ,OAAO,CAAC,OAAO,CAAC,KAAK,CAAC,KAAK,MAAM,KAAK;AACtE,QAAI,oBAAuB,QAAQ,KACjC,KAAI,OAAO;AAEb,WAAO;GACR,GAAE,CAAE,EAAQ;AAGb,UAAO,MAAM,OAAO,YAAY,MAAM,KAAK,GAAG,CAAC,OAAO,WAAW;EAClE;AAGD,SAAO;CACR;CAyCD,MAAM,WACJC,OACAF,aACAG,OAC6C;AAC7C,QAAM,eAAe,KAAK,UACxB,OAAM,IAAI,OACP,WACC,YACD;EAIL,MAAMC,UAAiB,CAAE;AACzB,OAAK,IAAI,IAAI,GAAG,IAAI,OAAO,KAAK;GAC9B,MAAM,kBACG,UAAU,aAAa,MAAM,AAAC,MAAc,GAAG,MAAM,GAAG;AAEjE,WAAQ,KACN,KAAK,SAAS,aAAa,UAAU,MAAM,KAAK,IAAI,MAAM,CAAC,KACzD,CAACC,WAAgB;AAEf,QAAI,iBAAiB,OAAO,WAAW,YAAY;KAEjD,MAAM,aAAa,OAAO,QAAQ,OAAO,CAAC,OACxC,CAAC,KAAK,CAAC,KAAK,MAAM,KAAK;AACrB,UAAI,oBAAuB,QAAQ,KACjC,KAAI,OAAO;AAEb,aAAO;KACR,GACD,CAAE,EACH;AAGD,YAAO,OAAO,YAAY,MAAM,KAAK,GAAG,CAAC,OAAO,WAAW;IAC5D;AAED,WAAO;GACR,EACF,CACF;EACF;AAED,SAAO,QAAQ,IAAI,QAAQ;CAC5B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkCD,KACEC,UACAC,OACsB;AACtB,QAAM,YAAY,KAAK,OACrB,OAAM,IAAI,OACP,QACC,SACD;AAIL,SAAO,KAAK,MAAM,UAAU,SAAS,CAAE,GAAE,MAAM,KAAK,GAAG;CACxD;AACF"}

package/dist/VitestTransactionIsolator-BIaMs4c2.mjs.map

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

package/dist/VitestTransactionIsolator-BKIrj3Uy.cjs.map

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