@geekmidas/testkit 0.2.0 → 0.3.1

package/dist/kysely.d.cts

@@ -1,6 +1,6 @@
-import { FakerFactory, faker } from "./faker-Dg3trU4a.cjs";
-import "./Factory-D7oHtI2D.cjs";
-import { KyselyFactory } from "./KyselyFactory-dYdviox2.cjs";
+import { FakerFactory, faker } from "./faker-Cg76aFNO.cjs";
+import { ExtractSeedAttrs, FactorySeed } from "./Factory-BK06XuDA.cjs";
+import { KyselyFactory } from "./KyselyFactory-Bu9ssWZP.cjs";
 import "./PostgresMigrator-D5UkK1_K.cjs";
 import { PostgresKyselyMigrator } from "./PostgresKyselyMigrator-CQ3aUoy_.cjs";
 import { DatabaseConnection, DatabaseFixtures, ExtendedDatabaseFixtures, FixtureCreators, IsolationLevel, TestWithExtendedFixtures, TransactionWrapperOptions } from "./VitestTransactionIsolator-CwQaxZLP.cjs";
@@ -125,5 +125,5 @@ declare function wrapVitestKyselyTransaction<Database, Extended extends Record<s
  */
 declare function extendWithFixtures<Database, Extended extends Record<string, unknown>, T extends ReturnType<TestAPI['extend']> = ReturnType<TestAPI['extend']>>(wrappedTest: T, fixtures: FixtureCreators<Transaction<Database>, Extended>): TestWithExtendedFixtures<Transaction<Database>, Extended, T>;
 //#endregion
-export { DatabaseFixtures, ExtendedDatabaseFixtures, FakerFactory, FixtureCreators, IsolationLevel, KyselyFactory, KyselyTransactionOptions, PostgresKyselyMigrator, TestWithExtendedFixtures, TransactionWrapperOptions, VitestKyselyTransactionIsolator, extendWithFixtures, faker, wrapVitestKyselyTransaction };
+export { DatabaseFixtures, ExtendedDatabaseFixtures, ExtractSeedAttrs, FactorySeed, FakerFactory, FixtureCreators, IsolationLevel, KyselyFactory, KyselyTransactionOptions, PostgresKyselyMigrator, TestWithExtendedFixtures, TransactionWrapperOptions, VitestKyselyTransactionIsolator, extendWithFixtures, faker, wrapVitestKyselyTransaction };
 //# sourceMappingURL=kysely.d.cts.map

package/dist/kysely.d.mts

@@ -1,6 +1,6 @@
 import { FakerFactory, faker } from "./faker-DHh7xs4u.mjs";
-import "./Factory-Cmr3s3-s.mjs";
-import { KyselyFactory } from "./KyselyFactory-BTdygZ-i.mjs";
+import { ExtractSeedAttrs, FactorySeed } from "./Factory-BcGJjLc8.mjs";
+import { KyselyFactory } from "./KyselyFactory-Cj-EultY.mjs";
 import "./PostgresMigrator-DQaRxoaY.mjs";
 import { PostgresKyselyMigrator } from "./PostgresKyselyMigrator-CIx3AFSR.mjs";
 import { DatabaseConnection, DatabaseFixtures, ExtendedDatabaseFixtures, FixtureCreators, IsolationLevel, TestWithExtendedFixtures, TransactionWrapperOptions } from "./VitestTransactionIsolator-BvR19bYn.mjs";
@@ -125,5 +125,5 @@ declare function wrapVitestKyselyTransaction<Database, Extended extends Record<s
  */
 declare function extendWithFixtures<Database, Extended extends Record<string, unknown>, T extends ReturnType<TestAPI['extend']> = ReturnType<TestAPI['extend']>>(wrappedTest: T, fixtures: FixtureCreators<Transaction<Database>, Extended>): TestWithExtendedFixtures<Transaction<Database>, Extended, T>;
 //#endregion
-export { DatabaseFixtures, ExtendedDatabaseFixtures, FakerFactory, FixtureCreators, IsolationLevel, KyselyFactory, KyselyTransactionOptions, PostgresKyselyMigrator, TestWithExtendedFixtures, TransactionWrapperOptions, VitestKyselyTransactionIsolator, extendWithFixtures, faker, wrapVitestKyselyTransaction };
+export { DatabaseFixtures, ExtendedDatabaseFixtures, ExtractSeedAttrs, FactorySeed, FakerFactory, FixtureCreators, IsolationLevel, KyselyFactory, KyselyTransactionOptions, PostgresKyselyMigrator, TestWithExtendedFixtures, TransactionWrapperOptions, VitestKyselyTransactionIsolator, extendWithFixtures, faker, wrapVitestKyselyTransaction };
 //# sourceMappingURL=kysely.d.mts.map

package/dist/kysely.mjs

@@ -1,6 +1,6 @@
-import "./Factory-z2m01hMj.mjs";
+import "./Factory-BFVnMMCC.mjs";
 import { faker } from "./faker-BGKYFoCT.mjs";
-import { KyselyFactory } from "./KyselyFactory-CXY5gJk2.mjs";
+import { KyselyFactory } from "./KyselyFactory-DMswpwji.mjs";
 import "./PostgresMigrator-DbuJGAVy.mjs";
 import { PostgresKyselyMigrator } from "./PostgresKyselyMigrator-upT-hmrz.mjs";
 import { IsolationLevel, extendWithFixtures } from "./VitestTransactionIsolator-DQ7tLqgV.mjs";

package/dist/kysely.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"kysely.mjs","names":["api: TestAPI","options: KyselyTransactionOptions<Database, Extended>","extendWithFixtures","wrappedTest: T","fixtures: FixtureCreators<Transaction<Database>, Extended>"],"sources":["../src/kysely.ts"],"sourcesContent":["import type { Kysely, Transaction } from 'kysely';\nimport type { TestAPI } from 'vitest';\nimport { VitestKyselyTransactionIsolator } from './VitestKyselyTransactionIsolator';\nimport {\n  type DatabaseConnection,\n  type FixtureCreators,\n  type IsolationLevel,\n  extendWithFixtures as baseExtendWithFixtures,\n} from './VitestTransactionIsolator';\n\n/**\n * Kysely-specific exports for test utilities.\n * Provides factories, migrators, and transaction isolators for Kysely ORM.\n */\n\nexport { KyselyFactory } from './KyselyFactory';\nexport { PostgresKyselyMigrator } from './PostgresKyselyMigrator';\nexport { VitestKyselyTransactionIsolator } from './VitestKyselyTransactionIsolator';\nexport { IsolationLevel } from './VitestTransactionIsolator';\nexport type {\n  DatabaseFixtures,\n  ExtendedDatabaseFixtures,\n  FixtureCreators,\n  TestWithExtendedFixtures,\n  TransactionWrapperOptions,\n} from './VitestTransactionIsolator';\n\n/**\n * Kysely-specific options for transaction wrapping.\n */\nexport interface KyselyTransactionOptions<\n  Database,\n  Extended extends Record<string, unknown> = {},\n> {\n  /** Function that creates or returns a Kysely database instance */\n  connection: DatabaseConnection<Kysely<Database>>;\n  /** Optional setup function to run within the transaction before each test */\n  setup?: (trx: Transaction<Database>) => Promise<void>;\n  /** Transaction isolation level (defaults to REPEATABLE_READ) */\n  isolationLevel?: IsolationLevel;\n  /** Additional fixtures that depend on the transaction */\n  fixtures?: FixtureCreators<Transaction<Database>, Extended>;\n}\n\n// Re-export faker and FakerFactory for type portability in declaration files\nexport { faker, type FakerFactory } from './faker';\n\n/**\n * Creates a wrapped Vitest test API with automatic transaction rollback for Kysely.\n * Each test runs in an isolated database transaction that is rolled back after completion.\n * This ensures tests don't affect each other's data and run faster than truncating tables.\n *\n * @template Database - The database schema type\n * @template Extended - Additional fixtures to provide\n * @param api - The Vitest test API (usually `test` from vitest)\n * @param options - Configuration options for transaction wrapping\n * @returns A wrapped test API that provides transaction isolation\n *\n * @example\n * ```typescript\n * import { test } from 'vitest';\n * import { wrapVitestKyselyTransaction } from '@geekmidas/testkit/kysely';\n * import { db } from './database';\n *\n * // Create isolated test with automatic rollback\n * const isolatedTest = wrapVitestKyselyTransaction(test, {\n *   connection: db,\n * });\n *\n * // Use in tests - each test gets its own transaction\n * isolatedTest('should create user', async ({ trx }) => {\n *   const user = await trx\n *     .insertInto('users')\n *     .values({ name: 'Test User', email: 'test@example.com' })\n *     .returningAll()\n *     .executeTakeFirst();\n *\n *   expect(user).toBeDefined();\n * });\n *\n * // With fixtures for factories\n * const it = wrapVitestKyselyTransaction<DB, { factory: Factory }>(test, {\n *   connection: db,\n *   fixtures: {\n *     factory: (trx) => new Factory(trx),\n *   },\n * });\n *\n * it('should create user with factory', async ({ trx, factory }) => {\n *   const user = await factory.insert('user', { name: 'Test' });\n *   expect(user.id).toBeDefined();\n * });\n * ```\n */\nexport function wrapVitestKyselyTransaction<\n  Database,\n  Extended extends Record<string, unknown> = {},\n>(api: TestAPI, options: KyselyTransactionOptions<Database, Extended>) {\n  const wrapper = new VitestKyselyTransactionIsolator<Database>(api);\n\n  return wrapper.wrapVitestWithTransaction(options);\n}\n\n/**\n * Extends a Kysely transaction-wrapped test with additional fixtures.\n * Each fixture receives the transaction and can create dependencies like factories or repositories.\n *\n * @template Database - The database schema type\n * @template Extended - The type of additional fixtures to provide\n * @param wrappedTest - The base wrapped test from wrapVitestKyselyTransaction\n * @param fixtures - Object mapping fixture names to creator functions\n * @returns An extended test API with both trx and the additional fixtures\n *\n * @example\n * ```typescript\n * import { test } from 'vitest';\n * import { wrapVitestKyselyTransaction, extendWithFixtures, KyselyFactory } from '@geekmidas/testkit/kysely';\n *\n * // Define your builders\n * const builders = {\n *   user: KyselyFactory.createBuilder<DB, 'users'>('users', ({ faker }) => ({\n *     name: faker.person.fullName(),\n *     email: faker.internet.email(),\n *   })),\n * };\n *\n * // Create base wrapped test\n * const baseTest = wrapVitestKyselyTransaction<DB>(test, {\n *   connection: db,\n *   setup: createTestTables,\n * });\n *\n * // Extend with fixtures - each fixture receives the transaction\n * const it = extendWithFixtures<DB, { factory: KyselyFactory<DB, typeof builders, {}> }>(\n *   baseTest,\n *   {\n *     factory: (trx) => new KyselyFactory(builders, {}, trx),\n *   }\n * );\n *\n * // Use in tests - both trx and factory are available\n * it('should create user with factory', async ({ trx, factory }) => {\n *   const user = await factory.insert('user', { name: 'Test User' });\n *   expect(user.id).toBeDefined();\n *\n *   // Verify in database\n *   const found = await trx\n *     .selectFrom('users')\n *     .where('id', '=', user.id)\n *     .selectAll()\n *     .executeTakeFirst();\n *   expect(found?.name).toBe('Test User');\n * });\n * ```\n */\nexport function extendWithFixtures<\n  Database,\n  Extended extends Record<string, unknown>,\n  T extends ReturnType<TestAPI['extend']> = ReturnType<TestAPI['extend']>,\n>(wrappedTest: T, fixtures: FixtureCreators<Transaction<Database>, Extended>) {\n  return baseExtendWithFixtures<Transaction<Database>, Extended, T>(\n    wrappedTest,\n    fixtures,\n  );\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8FA,SAAgB,4BAGdA,KAAcC,SAAuD;CACrE,MAAM,UAAU,IAAI,gCAA0C;AAE9D,QAAO,QAAQ,0BAA0B,QAAQ;AAClD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAsDD,SAAgBC,qBAIdC,aAAgBC,UAA4D;AAC5E,QAAO,mBACL,aACA,SACD;AACF"}
+{"version":3,"file":"kysely.mjs","names":["api: TestAPI","options: KyselyTransactionOptions<Database, Extended>","extendWithFixtures","wrappedTest: T","fixtures: FixtureCreators<Transaction<Database>, Extended>"],"sources":["../src/kysely.ts"],"sourcesContent":["import type { Kysely, Transaction } from 'kysely';\nimport type { TestAPI } from 'vitest';\nimport { VitestKyselyTransactionIsolator } from './VitestKyselyTransactionIsolator';\nimport {\n  type DatabaseConnection,\n  type FixtureCreators,\n  type IsolationLevel,\n  extendWithFixtures as baseExtendWithFixtures,\n} from './VitestTransactionIsolator';\n\n/**\n * Kysely-specific exports for test utilities.\n * Provides factories, migrators, and transaction isolators for Kysely ORM.\n */\n\nexport { KyselyFactory } from './KyselyFactory';\nexport type { ExtractSeedAttrs, FactorySeed } from './Factory';\nexport { PostgresKyselyMigrator } from './PostgresKyselyMigrator';\nexport { VitestKyselyTransactionIsolator } from './VitestKyselyTransactionIsolator';\nexport { IsolationLevel } from './VitestTransactionIsolator';\nexport type {\n  DatabaseFixtures,\n  ExtendedDatabaseFixtures,\n  FixtureCreators,\n  TestWithExtendedFixtures,\n  TransactionWrapperOptions,\n} from './VitestTransactionIsolator';\n\n/**\n * Kysely-specific options for transaction wrapping.\n */\nexport interface KyselyTransactionOptions<\n  Database,\n  Extended extends Record<string, unknown> = {},\n> {\n  /** Function that creates or returns a Kysely database instance */\n  connection: DatabaseConnection<Kysely<Database>>;\n  /** Optional setup function to run within the transaction before each test */\n  setup?: (trx: Transaction<Database>) => Promise<void>;\n  /** Transaction isolation level (defaults to REPEATABLE_READ) */\n  isolationLevel?: IsolationLevel;\n  /** Additional fixtures that depend on the transaction */\n  fixtures?: FixtureCreators<Transaction<Database>, Extended>;\n}\n\n// Re-export faker and FakerFactory for type portability in declaration files\nexport { faker, type FakerFactory } from './faker';\n\n/**\n * Creates a wrapped Vitest test API with automatic transaction rollback for Kysely.\n * Each test runs in an isolated database transaction that is rolled back after completion.\n * This ensures tests don't affect each other's data and run faster than truncating tables.\n *\n * @template Database - The database schema type\n * @template Extended - Additional fixtures to provide\n * @param api - The Vitest test API (usually `test` from vitest)\n * @param options - Configuration options for transaction wrapping\n * @returns A wrapped test API that provides transaction isolation\n *\n * @example\n * ```typescript\n * import { test } from 'vitest';\n * import { wrapVitestKyselyTransaction } from '@geekmidas/testkit/kysely';\n * import { db } from './database';\n *\n * // Create isolated test with automatic rollback\n * const isolatedTest = wrapVitestKyselyTransaction(test, {\n *   connection: db,\n * });\n *\n * // Use in tests - each test gets its own transaction\n * isolatedTest('should create user', async ({ trx }) => {\n *   const user = await trx\n *     .insertInto('users')\n *     .values({ name: 'Test User', email: 'test@example.com' })\n *     .returningAll()\n *     .executeTakeFirst();\n *\n *   expect(user).toBeDefined();\n * });\n *\n * // With fixtures for factories\n * const it = wrapVitestKyselyTransaction<DB, { factory: Factory }>(test, {\n *   connection: db,\n *   fixtures: {\n *     factory: (trx) => new Factory(trx),\n *   },\n * });\n *\n * it('should create user with factory', async ({ trx, factory }) => {\n *   const user = await factory.insert('user', { name: 'Test' });\n *   expect(user.id).toBeDefined();\n * });\n * ```\n */\nexport function wrapVitestKyselyTransaction<\n  Database,\n  Extended extends Record<string, unknown> = {},\n>(api: TestAPI, options: KyselyTransactionOptions<Database, Extended>) {\n  const wrapper = new VitestKyselyTransactionIsolator<Database>(api);\n\n  return wrapper.wrapVitestWithTransaction(options);\n}\n\n/**\n * Extends a Kysely transaction-wrapped test with additional fixtures.\n * Each fixture receives the transaction and can create dependencies like factories or repositories.\n *\n * @template Database - The database schema type\n * @template Extended - The type of additional fixtures to provide\n * @param wrappedTest - The base wrapped test from wrapVitestKyselyTransaction\n * @param fixtures - Object mapping fixture names to creator functions\n * @returns An extended test API with both trx and the additional fixtures\n *\n * @example\n * ```typescript\n * import { test } from 'vitest';\n * import { wrapVitestKyselyTransaction, extendWithFixtures, KyselyFactory } from '@geekmidas/testkit/kysely';\n *\n * // Define your builders\n * const builders = {\n *   user: KyselyFactory.createBuilder<DB, 'users'>('users', ({ faker }) => ({\n *     name: faker.person.fullName(),\n *     email: faker.internet.email(),\n *   })),\n * };\n *\n * // Create base wrapped test\n * const baseTest = wrapVitestKyselyTransaction<DB>(test, {\n *   connection: db,\n *   setup: createTestTables,\n * });\n *\n * // Extend with fixtures - each fixture receives the transaction\n * const it = extendWithFixtures<DB, { factory: KyselyFactory<DB, typeof builders, {}> }>(\n *   baseTest,\n *   {\n *     factory: (trx) => new KyselyFactory(builders, {}, trx),\n *   }\n * );\n *\n * // Use in tests - both trx and factory are available\n * it('should create user with factory', async ({ trx, factory }) => {\n *   const user = await factory.insert('user', { name: 'Test User' });\n *   expect(user.id).toBeDefined();\n *\n *   // Verify in database\n *   const found = await trx\n *     .selectFrom('users')\n *     .where('id', '=', user.id)\n *     .selectAll()\n *     .executeTakeFirst();\n *   expect(found?.name).toBe('Test User');\n * });\n * ```\n */\nexport function extendWithFixtures<\n  Database,\n  Extended extends Record<string, unknown>,\n  T extends ReturnType<TestAPI['extend']> = ReturnType<TestAPI['extend']>,\n>(wrappedTest: T, fixtures: FixtureCreators<Transaction<Database>, Extended>) {\n  return baseExtendWithFixtures<Transaction<Database>, Extended, T>(\n    wrappedTest,\n    fixtures,\n  );\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+FA,SAAgB,4BAGdA,KAAcC,SAAuD;CACrE,MAAM,UAAU,IAAI,gCAA0C;AAE9D,QAAO,QAAQ,0BAA0B,QAAQ;AAClD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAsDD,SAAgBC,qBAIdC,aAAgBC,UAA4D;AAC5E,QAAO,mBACL,aACA,SACD;AACF"}

package/dist/objection.cjs

@@ -1,6 +1,6 @@
-require('./Factory-WMhTNZ9S.cjs');
+require('./Factory-BhjUOBWN.cjs');
 const require_faker = require('./faker-B14IEMIN.cjs');
-const require_ObjectionFactory = require('./ObjectionFactory-Eb04AOnv.cjs');
+const require_ObjectionFactory = require('./ObjectionFactory-BeFBYcan.cjs');
 require('./PostgresMigrator-DFcNdCvD.cjs');
 const require_PostgresObjectionMigrator = require('./PostgresObjectionMigrator-BG6ymgnt.cjs');
 const require_VitestTransactionIsolator = require('./VitestTransactionIsolator-CMfJXZP8.cjs');

package/dist/objection.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"objection.cjs","names":["api: TestAPI","options: ObjectionTransactionOptions<Extended>","VitestObjectionTransactionIsolator","extendWithFixtures","wrappedTest: T","fixtures: FixtureCreators<Knex.Transaction, Extended>"],"sources":["../src/objection.ts"],"sourcesContent":["import type { Knex } from 'knex';\nimport type { TestAPI } from 'vitest';\nimport { VitestObjectionTransactionIsolator } from './VitestObjectionTransactionIsolator';\nimport {\n  type DatabaseConnection,\n  type FixtureCreators,\n  type IsolationLevel,\n  extendWithFixtures as baseExtendWithFixtures,\n} from './VitestTransactionIsolator';\n\n/**\n * Objection.js-specific exports for test utilities.\n * Provides factory implementation for creating test data with Objection.js ORM\n * and transaction isolation for test suites.\n */\n\nexport { ObjectionFactory } from './ObjectionFactory';\nexport { VitestObjectionTransactionIsolator } from './VitestObjectionTransactionIsolator';\nexport { IsolationLevel } from './VitestTransactionIsolator';\nexport { PostgresObjectionMigrator } from './PostgresObjectionMigrator';\nexport type {\n  DatabaseFixtures,\n  ExtendedDatabaseFixtures,\n  FixtureCreators,\n  TestWithExtendedFixtures,\n  TransactionWrapperOptions,\n} from './VitestTransactionIsolator';\n\n/**\n * Objection.js-specific options for transaction wrapping.\n */\nexport interface ObjectionTransactionOptions<\n  Extended extends Record<string, unknown> = {},\n> {\n  /** Function that creates or returns a Knex database connection */\n  connection: DatabaseConnection<Knex>;\n  /** Optional setup function to run within the transaction before each test */\n  setup?: (trx: Knex.Transaction) => Promise<void>;\n  /** Transaction isolation level (defaults to REPEATABLE_READ) */\n  isolationLevel?: IsolationLevel;\n  /** Additional fixtures that depend on the transaction */\n  fixtures?: FixtureCreators<Knex.Transaction, Extended>;\n}\n\n// Re-export faker and FakerFactory for type portability in declaration files\nexport { faker, type FakerFactory } from './faker';\n\n/**\n * Creates a wrapped Vitest test API with automatic transaction rollback for Objection.js.\n * Each test runs in an isolated database transaction that is rolled back after completion.\n * This ensures tests don't affect each other's data and run faster than truncating tables.\n *\n * @template Extended - Additional fixtures to provide\n * @param api - The Vitest test API (usually `test` from vitest)\n * @param options - Configuration options for transaction wrapping\n * @returns A wrapped test API that provides transaction isolation\n *\n * @example\n * ```typescript\n * import { test } from 'vitest';\n * import { wrapVitestObjectionTransaction } from '@geekmidas/testkit/objection';\n * import { knex } from './database';\n * import { User } from './models';\n *\n * // Create isolated test with automatic rollback\n * const isolatedTest = wrapVitestObjectionTransaction(test, {\n *   connection: knex,\n * });\n *\n * // Use in tests - each test gets its own transaction\n * isolatedTest('should create user', async ({ trx }) => {\n *   const user = await User.query(trx)\n *     .insert({ name: 'Test User', email: 'test@example.com' });\n *\n *   expect(user).toBeDefined();\n * });\n *\n * // With fixtures for factories\n * const it = wrapVitestObjectionTransaction<{ factory: Factory }>(test, {\n *   connection: knex,\n *   fixtures: {\n *     factory: (trx) => new Factory(trx),\n *   },\n * });\n *\n * it('should create user with factory', async ({ trx, factory }) => {\n *   const user = await factory.insert('user', { name: 'Test' });\n *   expect(user.id).toBeDefined();\n * });\n * ```\n */\nexport function wrapVitestObjectionTransaction<\n  Extended extends Record<string, unknown> = {},\n>(api: TestAPI, options: ObjectionTransactionOptions<Extended>) {\n  const wrapper = new VitestObjectionTransactionIsolator(api);\n\n  return wrapper.wrapVitestWithTransaction(options);\n}\n\n/**\n * Extends an Objection.js transaction-wrapped test with additional fixtures.\n * Each fixture receives the transaction and can create dependencies like factories or repositories.\n *\n * @template Extended - The type of additional fixtures to provide\n * @param wrappedTest - The base wrapped test from wrapVitestObjectionTransaction\n * @param fixtures - Object mapping fixture names to creator functions\n * @returns An extended test API with both trx and the additional fixtures\n *\n * @example\n * ```typescript\n * import { test } from 'vitest';\n * import { wrapVitestObjectionTransaction, extendWithFixtures, ObjectionFactory } from '@geekmidas/testkit/objection';\n * import { User } from './models';\n *\n * // Define your builders\n * const builders = {\n *   user: ObjectionFactory.createBuilder(User, ({ faker }) => ({\n *     name: faker.person.fullName(),\n *     email: faker.internet.email(),\n *   })),\n * };\n *\n * // Create base wrapped test\n * const baseTest = wrapVitestObjectionTransaction(test, {\n *   connection: knex,\n *   setup: createTestTables,\n * });\n *\n * // Extend with fixtures - each fixture receives the transaction\n * const it = extendWithFixtures<{ factory: ObjectionFactory<typeof builders, {}> }>(\n *   baseTest,\n *   {\n *     factory: (trx) => new ObjectionFactory(builders, {}, trx),\n *   }\n * );\n *\n * // Use in tests - both trx and factory are available\n * it('should create user with factory', async ({ trx, factory }) => {\n *   const user = await factory.insert('user', { name: 'Test User' });\n *   expect(user.id).toBeDefined();\n *\n *   // Verify in database\n *   const found = await User.query(trx).findById(user.id);\n *   expect(found?.name).toBe('Test User');\n * });\n * ```\n */\nexport function extendWithFixtures<\n  Extended extends Record<string, unknown>,\n  T extends ReturnType<TestAPI['extend']> = ReturnType<TestAPI['extend']>,\n>(wrappedTest: T, fixtures: FixtureCreators<Knex.Transaction, Extended>) {\n  return baseExtendWithFixtures<Knex.Transaction, Extended, T>(\n    wrappedTest,\n    fixtures,\n  );\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA2FA,SAAgB,+BAEdA,KAAcC,SAAgD;CAC9D,MAAM,UAAU,IAAIC,8EAAmC;AAEvD,QAAO,QAAQ,0BAA0B,QAAQ;AAClD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkDD,SAAgBC,qBAGdC,aAAgBC,UAAuD;AACvE,QAAO,qDACL,aACA,SACD;AACF"}
+{"version":3,"file":"objection.cjs","names":["api: TestAPI","options: ObjectionTransactionOptions<Extended>","VitestObjectionTransactionIsolator","extendWithFixtures","wrappedTest: T","fixtures: FixtureCreators<Knex.Transaction, Extended>"],"sources":["../src/objection.ts"],"sourcesContent":["import type { Knex } from 'knex';\nimport type { TestAPI } from 'vitest';\nimport { VitestObjectionTransactionIsolator } from './VitestObjectionTransactionIsolator';\nimport {\n  type DatabaseConnection,\n  type FixtureCreators,\n  type IsolationLevel,\n  extendWithFixtures as baseExtendWithFixtures,\n} from './VitestTransactionIsolator';\n\n/**\n * Objection.js-specific exports for test utilities.\n * Provides factory implementation for creating test data with Objection.js ORM\n * and transaction isolation for test suites.\n */\n\nexport { ObjectionFactory } from './ObjectionFactory';\nexport type { ExtractSeedAttrs, FactorySeed } from './Factory';\nexport { VitestObjectionTransactionIsolator } from './VitestObjectionTransactionIsolator';\nexport { IsolationLevel } from './VitestTransactionIsolator';\nexport { PostgresObjectionMigrator } from './PostgresObjectionMigrator';\nexport type {\n  DatabaseFixtures,\n  ExtendedDatabaseFixtures,\n  FixtureCreators,\n  TestWithExtendedFixtures,\n  TransactionWrapperOptions,\n} from './VitestTransactionIsolator';\n\n/**\n * Objection.js-specific options for transaction wrapping.\n */\nexport interface ObjectionTransactionOptions<\n  Extended extends Record<string, unknown> = {},\n> {\n  /** Function that creates or returns a Knex database connection */\n  connection: DatabaseConnection<Knex>;\n  /** Optional setup function to run within the transaction before each test */\n  setup?: (trx: Knex.Transaction) => Promise<void>;\n  /** Transaction isolation level (defaults to REPEATABLE_READ) */\n  isolationLevel?: IsolationLevel;\n  /** Additional fixtures that depend on the transaction */\n  fixtures?: FixtureCreators<Knex.Transaction, Extended>;\n}\n\n// Re-export faker and FakerFactory for type portability in declaration files\nexport { faker, type FakerFactory } from './faker';\n\n/**\n * Creates a wrapped Vitest test API with automatic transaction rollback for Objection.js.\n * Each test runs in an isolated database transaction that is rolled back after completion.\n * This ensures tests don't affect each other's data and run faster than truncating tables.\n *\n * @template Extended - Additional fixtures to provide\n * @param api - The Vitest test API (usually `test` from vitest)\n * @param options - Configuration options for transaction wrapping\n * @returns A wrapped test API that provides transaction isolation\n *\n * @example\n * ```typescript\n * import { test } from 'vitest';\n * import { wrapVitestObjectionTransaction } from '@geekmidas/testkit/objection';\n * import { knex } from './database';\n * import { User } from './models';\n *\n * // Create isolated test with automatic rollback\n * const isolatedTest = wrapVitestObjectionTransaction(test, {\n *   connection: knex,\n * });\n *\n * // Use in tests - each test gets its own transaction\n * isolatedTest('should create user', async ({ trx }) => {\n *   const user = await User.query(trx)\n *     .insert({ name: 'Test User', email: 'test@example.com' });\n *\n *   expect(user).toBeDefined();\n * });\n *\n * // With fixtures for factories\n * const it = wrapVitestObjectionTransaction<{ factory: Factory }>(test, {\n *   connection: knex,\n *   fixtures: {\n *     factory: (trx) => new Factory(trx),\n *   },\n * });\n *\n * it('should create user with factory', async ({ trx, factory }) => {\n *   const user = await factory.insert('user', { name: 'Test' });\n *   expect(user.id).toBeDefined();\n * });\n * ```\n */\nexport function wrapVitestObjectionTransaction<\n  Extended extends Record<string, unknown> = {},\n>(api: TestAPI, options: ObjectionTransactionOptions<Extended>) {\n  const wrapper = new VitestObjectionTransactionIsolator(api);\n\n  return wrapper.wrapVitestWithTransaction(options);\n}\n\n/**\n * Extends an Objection.js transaction-wrapped test with additional fixtures.\n * Each fixture receives the transaction and can create dependencies like factories or repositories.\n *\n * @template Extended - The type of additional fixtures to provide\n * @param wrappedTest - The base wrapped test from wrapVitestObjectionTransaction\n * @param fixtures - Object mapping fixture names to creator functions\n * @returns An extended test API with both trx and the additional fixtures\n *\n * @example\n * ```typescript\n * import { test } from 'vitest';\n * import { wrapVitestObjectionTransaction, extendWithFixtures, ObjectionFactory } from '@geekmidas/testkit/objection';\n * import { User } from './models';\n *\n * // Define your builders\n * const builders = {\n *   user: ObjectionFactory.createBuilder(User, ({ faker }) => ({\n *     name: faker.person.fullName(),\n *     email: faker.internet.email(),\n *   })),\n * };\n *\n * // Create base wrapped test\n * const baseTest = wrapVitestObjectionTransaction(test, {\n *   connection: knex,\n *   setup: createTestTables,\n * });\n *\n * // Extend with fixtures - each fixture receives the transaction\n * const it = extendWithFixtures<{ factory: ObjectionFactory<typeof builders, {}> }>(\n *   baseTest,\n *   {\n *     factory: (trx) => new ObjectionFactory(builders, {}, trx),\n *   }\n * );\n *\n * // Use in tests - both trx and factory are available\n * it('should create user with factory', async ({ trx, factory }) => {\n *   const user = await factory.insert('user', { name: 'Test User' });\n *   expect(user.id).toBeDefined();\n *\n *   // Verify in database\n *   const found = await User.query(trx).findById(user.id);\n *   expect(found?.name).toBe('Test User');\n * });\n * ```\n */\nexport function extendWithFixtures<\n  Extended extends Record<string, unknown>,\n  T extends ReturnType<TestAPI['extend']> = ReturnType<TestAPI['extend']>,\n>(wrappedTest: T, fixtures: FixtureCreators<Knex.Transaction, Extended>) {\n  return baseExtendWithFixtures<Knex.Transaction, Extended, T>(\n    wrappedTest,\n    fixtures,\n  );\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4FA,SAAgB,+BAEdA,KAAcC,SAAgD;CAC9D,MAAM,UAAU,IAAIC,8EAAmC;AAEvD,QAAO,QAAQ,0BAA0B,QAAQ;AAClD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkDD,SAAgBC,qBAGdC,aAAgBC,UAAuD;AACvE,QAAO,qDACL,aACA,SACD;AACF"}

package/dist/objection.d.cts

@@ -1,6 +1,6 @@
-import { FakerFactory, faker } from "./faker-Dg3trU4a.cjs";
-import "./Factory-D7oHtI2D.cjs";
-import { ObjectionFactory } from "./ObjectionFactory-0gUdx8bB.cjs";
+import { FakerFactory, faker } from "./faker-Cg76aFNO.cjs";
+import { ExtractSeedAttrs, FactorySeed } from "./Factory-BK06XuDA.cjs";
+import { ObjectionFactory } from "./ObjectionFactory-tKWZOiYO.cjs";
 import "./PostgresMigrator-D5UkK1_K.cjs";
 import { PostgresObjectionMigrator } from "./PostgresObjectionMigrator-CZHHcCOv.cjs";
 import { DatabaseConnection, DatabaseFixtures, ExtendedDatabaseFixtures, FixtureCreators, IsolationLevel, TestWithExtendedFixtures, TransactionWrapperOptions } from "./VitestTransactionIsolator-CwQaxZLP.cjs";
@@ -118,5 +118,5 @@ declare function wrapVitestObjectionTransaction<Extended extends Record<string,
  */
 declare function extendWithFixtures<Extended extends Record<string, unknown>, T extends ReturnType<TestAPI['extend']> = ReturnType<TestAPI['extend']>>(wrappedTest: T, fixtures: FixtureCreators<Knex.Transaction, Extended>): TestWithExtendedFixtures<Knex.Transaction<any, any[]>, Extended, T>;
 //#endregion
-export { DatabaseFixtures, ExtendedDatabaseFixtures, FakerFactory, FixtureCreators, IsolationLevel, ObjectionFactory, ObjectionTransactionOptions, PostgresObjectionMigrator, TestWithExtendedFixtures, TransactionWrapperOptions, VitestObjectionTransactionIsolator, extendWithFixtures, faker, wrapVitestObjectionTransaction };
+export { DatabaseFixtures, ExtendedDatabaseFixtures, ExtractSeedAttrs, FactorySeed, FakerFactory, FixtureCreators, IsolationLevel, ObjectionFactory, ObjectionTransactionOptions, PostgresObjectionMigrator, TestWithExtendedFixtures, TransactionWrapperOptions, VitestObjectionTransactionIsolator, extendWithFixtures, faker, wrapVitestObjectionTransaction };
 //# sourceMappingURL=objection.d.cts.map

package/dist/objection.d.mts

@@ -1,6 +1,6 @@
 import { FakerFactory, faker } from "./faker-DHh7xs4u.mjs";
-import "./Factory-Cmr3s3-s.mjs";
-import { ObjectionFactory } from "./ObjectionFactory-BagGjikT.mjs";
+import { ExtractSeedAttrs, FactorySeed } from "./Factory-BcGJjLc8.mjs";
+import { ObjectionFactory } from "./ObjectionFactory-DL4qkuF1.mjs";
 import "./PostgresMigrator-DQaRxoaY.mjs";
 import { PostgresObjectionMigrator } from "./PostgresObjectionMigrator-D_hCcrQu.mjs";
 import { DatabaseConnection, DatabaseFixtures, ExtendedDatabaseFixtures, FixtureCreators, IsolationLevel, TestWithExtendedFixtures, TransactionWrapperOptions } from "./VitestTransactionIsolator-BvR19bYn.mjs";
@@ -118,5 +118,5 @@ declare function wrapVitestObjectionTransaction<Extended extends Record<string,
  */
 declare function extendWithFixtures<Extended extends Record<string, unknown>, T extends ReturnType<TestAPI['extend']> = ReturnType<TestAPI['extend']>>(wrappedTest: T, fixtures: FixtureCreators<Knex.Transaction, Extended>): TestWithExtendedFixtures<Knex.Transaction<any, any[]>, Extended, T>;
 //#endregion
-export { DatabaseFixtures, ExtendedDatabaseFixtures, FakerFactory, FixtureCreators, IsolationLevel, ObjectionFactory, ObjectionTransactionOptions, PostgresObjectionMigrator, TestWithExtendedFixtures, TransactionWrapperOptions, VitestObjectionTransactionIsolator, extendWithFixtures, faker, wrapVitestObjectionTransaction };
+export { DatabaseFixtures, ExtendedDatabaseFixtures, ExtractSeedAttrs, FactorySeed, FakerFactory, FixtureCreators, IsolationLevel, ObjectionFactory, ObjectionTransactionOptions, PostgresObjectionMigrator, TestWithExtendedFixtures, TransactionWrapperOptions, VitestObjectionTransactionIsolator, extendWithFixtures, faker, wrapVitestObjectionTransaction };
 //# sourceMappingURL=objection.d.mts.map

package/dist/objection.mjs

@@ -1,6 +1,6 @@
-import "./Factory-z2m01hMj.mjs";
+import "./Factory-BFVnMMCC.mjs";
 import { faker } from "./faker-BGKYFoCT.mjs";
-import { ObjectionFactory } from "./ObjectionFactory-zf2fLKrL.mjs";
+import { ObjectionFactory } from "./ObjectionFactory-QCJ7u0Ql.mjs";
 import "./PostgresMigrator-DbuJGAVy.mjs";
 import { PostgresObjectionMigrator } from "./PostgresObjectionMigrator-DPj2pOpX.mjs";
 import { IsolationLevel, extendWithFixtures } from "./VitestTransactionIsolator-DQ7tLqgV.mjs";

package/dist/objection.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"objection.mjs","names":["api: TestAPI","options: ObjectionTransactionOptions<Extended>","extendWithFixtures","wrappedTest: T","fixtures: FixtureCreators<Knex.Transaction, Extended>"],"sources":["../src/objection.ts"],"sourcesContent":["import type { Knex } from 'knex';\nimport type { TestAPI } from 'vitest';\nimport { VitestObjectionTransactionIsolator } from './VitestObjectionTransactionIsolator';\nimport {\n  type DatabaseConnection,\n  type FixtureCreators,\n  type IsolationLevel,\n  extendWithFixtures as baseExtendWithFixtures,\n} from './VitestTransactionIsolator';\n\n/**\n * Objection.js-specific exports for test utilities.\n * Provides factory implementation for creating test data with Objection.js ORM\n * and transaction isolation for test suites.\n */\n\nexport { ObjectionFactory } from './ObjectionFactory';\nexport { VitestObjectionTransactionIsolator } from './VitestObjectionTransactionIsolator';\nexport { IsolationLevel } from './VitestTransactionIsolator';\nexport { PostgresObjectionMigrator } from './PostgresObjectionMigrator';\nexport type {\n  DatabaseFixtures,\n  ExtendedDatabaseFixtures,\n  FixtureCreators,\n  TestWithExtendedFixtures,\n  TransactionWrapperOptions,\n} from './VitestTransactionIsolator';\n\n/**\n * Objection.js-specific options for transaction wrapping.\n */\nexport interface ObjectionTransactionOptions<\n  Extended extends Record<string, unknown> = {},\n> {\n  /** Function that creates or returns a Knex database connection */\n  connection: DatabaseConnection<Knex>;\n  /** Optional setup function to run within the transaction before each test */\n  setup?: (trx: Knex.Transaction) => Promise<void>;\n  /** Transaction isolation level (defaults to REPEATABLE_READ) */\n  isolationLevel?: IsolationLevel;\n  /** Additional fixtures that depend on the transaction */\n  fixtures?: FixtureCreators<Knex.Transaction, Extended>;\n}\n\n// Re-export faker and FakerFactory for type portability in declaration files\nexport { faker, type FakerFactory } from './faker';\n\n/**\n * Creates a wrapped Vitest test API with automatic transaction rollback for Objection.js.\n * Each test runs in an isolated database transaction that is rolled back after completion.\n * This ensures tests don't affect each other's data and run faster than truncating tables.\n *\n * @template Extended - Additional fixtures to provide\n * @param api - The Vitest test API (usually `test` from vitest)\n * @param options - Configuration options for transaction wrapping\n * @returns A wrapped test API that provides transaction isolation\n *\n * @example\n * ```typescript\n * import { test } from 'vitest';\n * import { wrapVitestObjectionTransaction } from '@geekmidas/testkit/objection';\n * import { knex } from './database';\n * import { User } from './models';\n *\n * // Create isolated test with automatic rollback\n * const isolatedTest = wrapVitestObjectionTransaction(test, {\n *   connection: knex,\n * });\n *\n * // Use in tests - each test gets its own transaction\n * isolatedTest('should create user', async ({ trx }) => {\n *   const user = await User.query(trx)\n *     .insert({ name: 'Test User', email: 'test@example.com' });\n *\n *   expect(user).toBeDefined();\n * });\n *\n * // With fixtures for factories\n * const it = wrapVitestObjectionTransaction<{ factory: Factory }>(test, {\n *   connection: knex,\n *   fixtures: {\n *     factory: (trx) => new Factory(trx),\n *   },\n * });\n *\n * it('should create user with factory', async ({ trx, factory }) => {\n *   const user = await factory.insert('user', { name: 'Test' });\n *   expect(user.id).toBeDefined();\n * });\n * ```\n */\nexport function wrapVitestObjectionTransaction<\n  Extended extends Record<string, unknown> = {},\n>(api: TestAPI, options: ObjectionTransactionOptions<Extended>) {\n  const wrapper = new VitestObjectionTransactionIsolator(api);\n\n  return wrapper.wrapVitestWithTransaction(options);\n}\n\n/**\n * Extends an Objection.js transaction-wrapped test with additional fixtures.\n * Each fixture receives the transaction and can create dependencies like factories or repositories.\n *\n * @template Extended - The type of additional fixtures to provide\n * @param wrappedTest - The base wrapped test from wrapVitestObjectionTransaction\n * @param fixtures - Object mapping fixture names to creator functions\n * @returns An extended test API with both trx and the additional fixtures\n *\n * @example\n * ```typescript\n * import { test } from 'vitest';\n * import { wrapVitestObjectionTransaction, extendWithFixtures, ObjectionFactory } from '@geekmidas/testkit/objection';\n * import { User } from './models';\n *\n * // Define your builders\n * const builders = {\n *   user: ObjectionFactory.createBuilder(User, ({ faker }) => ({\n *     name: faker.person.fullName(),\n *     email: faker.internet.email(),\n *   })),\n * };\n *\n * // Create base wrapped test\n * const baseTest = wrapVitestObjectionTransaction(test, {\n *   connection: knex,\n *   setup: createTestTables,\n * });\n *\n * // Extend with fixtures - each fixture receives the transaction\n * const it = extendWithFixtures<{ factory: ObjectionFactory<typeof builders, {}> }>(\n *   baseTest,\n *   {\n *     factory: (trx) => new ObjectionFactory(builders, {}, trx),\n *   }\n * );\n *\n * // Use in tests - both trx and factory are available\n * it('should create user with factory', async ({ trx, factory }) => {\n *   const user = await factory.insert('user', { name: 'Test User' });\n *   expect(user.id).toBeDefined();\n *\n *   // Verify in database\n *   const found = await User.query(trx).findById(user.id);\n *   expect(found?.name).toBe('Test User');\n * });\n * ```\n */\nexport function extendWithFixtures<\n  Extended extends Record<string, unknown>,\n  T extends ReturnType<TestAPI['extend']> = ReturnType<TestAPI['extend']>,\n>(wrappedTest: T, fixtures: FixtureCreators<Knex.Transaction, Extended>) {\n  return baseExtendWithFixtures<Knex.Transaction, Extended, T>(\n    wrappedTest,\n    fixtures,\n  );\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA2FA,SAAgB,+BAEdA,KAAcC,SAAgD;CAC9D,MAAM,UAAU,IAAI,mCAAmC;AAEvD,QAAO,QAAQ,0BAA0B,QAAQ;AAClD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkDD,SAAgBC,qBAGdC,aAAgBC,UAAuD;AACvE,QAAO,mBACL,aACA,SACD;AACF"}
+{"version":3,"file":"objection.mjs","names":["api: TestAPI","options: ObjectionTransactionOptions<Extended>","extendWithFixtures","wrappedTest: T","fixtures: FixtureCreators<Knex.Transaction, Extended>"],"sources":["../src/objection.ts"],"sourcesContent":["import type { Knex } from 'knex';\nimport type { TestAPI } from 'vitest';\nimport { VitestObjectionTransactionIsolator } from './VitestObjectionTransactionIsolator';\nimport {\n  type DatabaseConnection,\n  type FixtureCreators,\n  type IsolationLevel,\n  extendWithFixtures as baseExtendWithFixtures,\n} from './VitestTransactionIsolator';\n\n/**\n * Objection.js-specific exports for test utilities.\n * Provides factory implementation for creating test data with Objection.js ORM\n * and transaction isolation for test suites.\n */\n\nexport { ObjectionFactory } from './ObjectionFactory';\nexport type { ExtractSeedAttrs, FactorySeed } from './Factory';\nexport { VitestObjectionTransactionIsolator } from './VitestObjectionTransactionIsolator';\nexport { IsolationLevel } from './VitestTransactionIsolator';\nexport { PostgresObjectionMigrator } from './PostgresObjectionMigrator';\nexport type {\n  DatabaseFixtures,\n  ExtendedDatabaseFixtures,\n  FixtureCreators,\n  TestWithExtendedFixtures,\n  TransactionWrapperOptions,\n} from './VitestTransactionIsolator';\n\n/**\n * Objection.js-specific options for transaction wrapping.\n */\nexport interface ObjectionTransactionOptions<\n  Extended extends Record<string, unknown> = {},\n> {\n  /** Function that creates or returns a Knex database connection */\n  connection: DatabaseConnection<Knex>;\n  /** Optional setup function to run within the transaction before each test */\n  setup?: (trx: Knex.Transaction) => Promise<void>;\n  /** Transaction isolation level (defaults to REPEATABLE_READ) */\n  isolationLevel?: IsolationLevel;\n  /** Additional fixtures that depend on the transaction */\n  fixtures?: FixtureCreators<Knex.Transaction, Extended>;\n}\n\n// Re-export faker and FakerFactory for type portability in declaration files\nexport { faker, type FakerFactory } from './faker';\n\n/**\n * Creates a wrapped Vitest test API with automatic transaction rollback for Objection.js.\n * Each test runs in an isolated database transaction that is rolled back after completion.\n * This ensures tests don't affect each other's data and run faster than truncating tables.\n *\n * @template Extended - Additional fixtures to provide\n * @param api - The Vitest test API (usually `test` from vitest)\n * @param options - Configuration options for transaction wrapping\n * @returns A wrapped test API that provides transaction isolation\n *\n * @example\n * ```typescript\n * import { test } from 'vitest';\n * import { wrapVitestObjectionTransaction } from '@geekmidas/testkit/objection';\n * import { knex } from './database';\n * import { User } from './models';\n *\n * // Create isolated test with automatic rollback\n * const isolatedTest = wrapVitestObjectionTransaction(test, {\n *   connection: knex,\n * });\n *\n * // Use in tests - each test gets its own transaction\n * isolatedTest('should create user', async ({ trx }) => {\n *   const user = await User.query(trx)\n *     .insert({ name: 'Test User', email: 'test@example.com' });\n *\n *   expect(user).toBeDefined();\n * });\n *\n * // With fixtures for factories\n * const it = wrapVitestObjectionTransaction<{ factory: Factory }>(test, {\n *   connection: knex,\n *   fixtures: {\n *     factory: (trx) => new Factory(trx),\n *   },\n * });\n *\n * it('should create user with factory', async ({ trx, factory }) => {\n *   const user = await factory.insert('user', { name: 'Test' });\n *   expect(user.id).toBeDefined();\n * });\n * ```\n */\nexport function wrapVitestObjectionTransaction<\n  Extended extends Record<string, unknown> = {},\n>(api: TestAPI, options: ObjectionTransactionOptions<Extended>) {\n  const wrapper = new VitestObjectionTransactionIsolator(api);\n\n  return wrapper.wrapVitestWithTransaction(options);\n}\n\n/**\n * Extends an Objection.js transaction-wrapped test with additional fixtures.\n * Each fixture receives the transaction and can create dependencies like factories or repositories.\n *\n * @template Extended - The type of additional fixtures to provide\n * @param wrappedTest - The base wrapped test from wrapVitestObjectionTransaction\n * @param fixtures - Object mapping fixture names to creator functions\n * @returns An extended test API with both trx and the additional fixtures\n *\n * @example\n * ```typescript\n * import { test } from 'vitest';\n * import { wrapVitestObjectionTransaction, extendWithFixtures, ObjectionFactory } from '@geekmidas/testkit/objection';\n * import { User } from './models';\n *\n * // Define your builders\n * const builders = {\n *   user: ObjectionFactory.createBuilder(User, ({ faker }) => ({\n *     name: faker.person.fullName(),\n *     email: faker.internet.email(),\n *   })),\n * };\n *\n * // Create base wrapped test\n * const baseTest = wrapVitestObjectionTransaction(test, {\n *   connection: knex,\n *   setup: createTestTables,\n * });\n *\n * // Extend with fixtures - each fixture receives the transaction\n * const it = extendWithFixtures<{ factory: ObjectionFactory<typeof builders, {}> }>(\n *   baseTest,\n *   {\n *     factory: (trx) => new ObjectionFactory(builders, {}, trx),\n *   }\n * );\n *\n * // Use in tests - both trx and factory are available\n * it('should create user with factory', async ({ trx, factory }) => {\n *   const user = await factory.insert('user', { name: 'Test User' });\n *   expect(user.id).toBeDefined();\n *\n *   // Verify in database\n *   const found = await User.query(trx).findById(user.id);\n *   expect(found?.name).toBe('Test User');\n * });\n * ```\n */\nexport function extendWithFixtures<\n  Extended extends Record<string, unknown>,\n  T extends ReturnType<TestAPI['extend']> = ReturnType<TestAPI['extend']>,\n>(wrappedTest: T, fixtures: FixtureCreators<Knex.Transaction, Extended>) {\n  return baseExtendWithFixtures<Knex.Transaction, Extended, T>(\n    wrappedTest,\n    fixtures,\n  );\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4FA,SAAgB,+BAEdA,KAAcC,SAAgD;CAC9D,MAAM,UAAU,IAAI,mCAAmC;AAEvD,QAAO,QAAQ,0BAA0B,QAAQ;AAClD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkDD,SAAgBC,qBAGdC,aAAgBC,UAAuD;AACvE,QAAO,mBACL,aACA,SACD;AACF"}

package/dist/os/directory.d.cts

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

package/dist/os/directory.d.mts

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

package/dist/os/index.d.cts

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

package/dist/os/index.d.mts

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@geekmidas/testkit",
-  "version": "0.2.0",
+  "version": "0.3.1",
   "private": false,
   "type": "module",
   "exports": {
@@ -43,6 +43,11 @@
       "types": "./dist/better-auth.d.ts",
       "import": "./dist/better-auth.mjs",
       "require": "./dist/better-auth.cjs"
+    },
+    "./benchmark": {
+      "types": "./dist/benchmark.d.ts",
+      "import": "./dist/benchmark.mjs",
+      "require": "./dist/benchmark.cjs"
     }
   },
   "dependencies": {

package/src/Factory.ts

@@ -39,7 +39,7 @@ export abstract class Factory<
    *
    * @example
    * ```typescript
-   * const userWithPostsSeed = Factory.createSeed(async (attrs, factory, db) => {
+   * const userWithPostsSeed = Factory.createSeed(async ({ attrs, factory, db }) => {
    *   const user = await factory.insert('user', attrs);
    *   return user;
    * });
@@ -86,7 +86,7 @@ export abstract class Factory<
    */
   abstract seed<K extends keyof Seeds>(
     seedName: K,
-    attrs?: Parameters<Seeds[K]>[0],
+    attrs?: ExtractSeedAttrs<Seeds[K]>,
   ): ReturnType<Seeds[K]>;
 }
 
@@ -133,15 +133,16 @@ export type MixedFactoryBuilder<
  * @template Result - The type of object returned by the seed
  * @template DB - The database connection type (Kysely, Knex, etc.)
  *
- * @param attrs - Configuration attributes for the seed
- * @param factory - The factory instance for creating records
- * @param db - The database connection
+ * @param context - Object containing attrs, factory, and db
+ * @param context.attrs - Configuration attributes for the seed
+ * @param context.factory - The factory instance for creating records
+ * @param context.db - The database connection
  * @returns A promise resolving to the seed result
  *
  * @example
  * ```typescript
  * const userWithPostsSeed: FactorySeed<{ postCount?: number }, Factory, User, DB> =
- *   async (attrs, factory, db) => {
+ *   async ({ attrs, factory, db }) => {
  *     const user = await factory.insert('user', attrs);
  *     const postCount = attrs.postCount || 3;
  *
@@ -153,8 +154,21 @@ export type MixedFactoryBuilder<
  *   };
  * ```
  */
-export type FactorySeed<Attrs = any, Factory = any, Result = any, DB = any> = (
-  attrs: Attrs,
-  factory: Factory,
-  db: DB,
-) => Promise<Result>;
+export type FactorySeed<
+  Attrs = any,
+  Factory = any,
+  Result = any,
+  DB = any,
+> = (context: { attrs: Attrs; factory: Factory; db: DB }) => Promise<Result>;
+
+/**
+ * Helper type to extract the Attrs type from a FactorySeed function.
+ * Used internally by Factory implementations to correctly type the seed method parameters.
+ */
+export type ExtractSeedAttrs<T> = T extends (context: {
+  attrs: infer A;
+  factory: any;
+  db: any;
+}) => any
+  ? A
+  : never;

package/src/KyselyFactory.ts

@@ -4,7 +4,7 @@ import type {
   Kysely,
   Selectable,
 } from 'kysely';
-import { Factory, type FactorySeed } from './Factory.ts';
+import { type ExtractSeedAttrs, Factory, type FactorySeed } from './Factory.ts';
 import { type FakerFactory, faker } from './faker.ts';
 
 /**
@@ -55,8 +55,21 @@ export class KyselyFactory<
    * Inherits from the base Factory class implementation.
    *
    * @template Seed - The seed function type
-   * @param seedFn - The seed function to wrap
+   * @param seedFn - The seed function to wrap (receives { attrs, factory, db } object)
    * @returns The same seed function with proper typing
+   *
+   * @example
+   * ```typescript
+   * const seeds = {
+   *   userWithPosts: KyselyFactory.createSeed(
+   *     async ({ attrs, factory }) => {
+   *       const user = await factory.insert('user', attrs);
+   *       await factory.insertMany(3, 'post', { userId: user.id });
+   *       return user;
+   *     },
+   *   ),
+   * };
+   * ```
    */
   static createSeed<Seed extends FactorySeed>(seedFn: Seed): Seed {
     return Factory.createSeed(seedFn);
@@ -359,7 +372,7 @@ export class KyselyFactory<
    */
   seed<K extends keyof Seeds>(
     seedName: K,
-    attrs?: Parameters<Seeds[K]>[0],
+    attrs?: ExtractSeedAttrs<Seeds[K]>,
   ): ReturnType<Seeds[K]> {
     if (!(seedName in this.seeds)) {
       throw new Error(
@@ -369,6 +382,10 @@ export class KyselyFactory<
       );
     }
 
-    return this.seeds[seedName](attrs || {}, this, this.db);
+    return this.seeds[seedName]({
+      attrs: attrs || {},
+      factory: this,
+      db: this.db,
+    });
   }
 }

package/src/ObjectionFactory.ts

@@ -1,6 +1,6 @@
 import type { Knex } from 'knex';
 import type { Model } from 'objection';
-import { Factory, type FactorySeed } from './Factory.ts';
+import { type ExtractSeedAttrs, Factory, type FactorySeed } from './Factory.ts';
 import { type FakerFactory, faker } from './faker.ts';
 
 /**
@@ -48,8 +48,21 @@ export class ObjectionFactory<
    * Inherits from the base Factory class implementation.
    *
    * @template Seed - The seed function type
-   * @param seedFn - The seed function to wrap
+   * @param seedFn - The seed function to wrap (receives { attrs, factory, db } object)
    * @returns The same seed function with proper typing
+   *
+   * @example
+   * ```typescript
+   * const seeds = {
+   *   userWithPosts: ObjectionFactory.createSeed(
+   *     async ({ attrs, factory }) => {
+   *       const user = await factory.insert('user', attrs);
+   *       await factory.insertMany(3, 'post', { userId: user.id });
+   *       return user;
+   *     },
+   *   ),
+   * };
+   * ```
    */
   static createSeed<Seed extends FactorySeed>(seedFn: Seed): Seed {
     return Factory.createSeed(seedFn);
@@ -381,7 +394,7 @@ export class ObjectionFactory<
    */
   seed<K extends keyof Seeds>(
     seedName: K,
-    attrs?: Parameters<Seeds[K]>[0],
+    attrs?: ExtractSeedAttrs<Seeds[K]>,
   ): ReturnType<Seeds[K]> {
     if (!(seedName in this.seeds)) {
       throw new Error(
@@ -391,6 +404,10 @@ export class ObjectionFactory<
       );
     }
 
-    return this.seeds[seedName](attrs || {}, this, this.db);
+    return this.seeds[seedName]({
+      attrs: attrs || {},
+      factory: this,
+      db: this.db,
+    });
   }
 }

package/src/__tests__/Factory.spec.ts

@@ -46,7 +46,11 @@ describe('Factory', () => {
 
   describe('createSeed static method', () => {
     it('should return the seed function unchanged', () => {
-      const seedFn = async (attrs: any, factory: any, db: any) => {
+      const seedFn = async ({
+        attrs,
+        factory,
+        db,
+      }: { attrs: any; factory: any; db: any }) => {
         return { id: 1, name: 'test' };
       };
 
@@ -57,12 +61,14 @@ describe('Factory', () => {
     });
 
     it('should work with different seed function signatures', () => {
-      const simpleSeed = () => Promise.resolve({ simple: true });
-      const complexSeed = async (
-        attrs: { name: string },
-        factory: any,
-        db: any,
-      ) => {
+      const simpleSeed = async () => ({ simple: true });
+      const complexSeed = async ({
+        attrs,
+      }: {
+        attrs: { name: string };
+        factory: any;
+        db: any;
+      }) => {
         return { name: attrs.name, created: true };
       };
 
@@ -124,8 +130,8 @@ describe('Factory', () => {
     });
 
     it('should properly type FactorySeed', () => {
-      // Test that FactorySeed requires async return
-      const seed: FactorySeed = async (attrs, factory, db) => ({
+      // Test that FactorySeed requires async return with object parameter
+      const seed: FactorySeed = async ({ attrs, factory, db }) => ({
         seeded: true,
       });
 
@@ -155,7 +161,7 @@ describe('Factory types', () => {
       TestFactory,
       { created: number },
       any
-    > = async (attrs, factory, db) => {
+    > = async ({ attrs }) => {
       return { created: attrs.count };
     };
 

package/src/__tests__/KyselyFactory.spec.ts

@@ -279,7 +279,10 @@ describe('KyselyFactory', () => {
 
       const seeds = {
         createAdminUser: KyselyFactory.createSeed(
-          async (attrs: { name?: string }, factory: any, db: any) => {
+          async ({
+            attrs,
+            factory,
+          }: { attrs: { name?: string }; factory: any; db: any }) => {
             return await factory.insert('user', {
               name: attrs.name || 'Admin User',
               email: 'admin@example.com',
@@ -319,11 +322,14 @@ describe('KyselyFactory', () => {
 
         const seeds = {
           createCustomUser: KyselyFactory.createSeed(
-            async (
-              attrs: { name: string; email: string },
-              factory: any,
-              db: any,
-            ) => {
+            async ({
+              attrs,
+              factory,
+            }: {
+              attrs: { name: string; email: string };
+              factory: any;
+              db: any;
+            }) => {
               return await factory.insert('user', attrs);
             },
           ),