@geekmidas/testkit 0.0.17 → 0.1.0

package/dist/objection.d.mts

@@ -1,10 +1,10 @@
-import "./faker-Br8MzXil.mjs";
-import "./Factory-CRquB4vz.mjs";
-import { ObjectionFactory } from "./ObjectionFactory-C3tHvX1d.mjs";
+import { FakerFactory, faker } from "./faker-DHh7xs4u.mjs";
+import "./Factory-Cmr3s3-s.mjs";
+import { ObjectionFactory } from "./ObjectionFactory-BagGjikT.mjs";
 import "./PostgresMigrator-DQaRxoaY.mjs";
 import { PostgresObjectionMigrator } from "./PostgresObjectionMigrator-D_hCcrQu.mjs";
-import { DatabaseConnection, IsolationLevel } from "./VitestTransactionIsolator-CsfJBxcb.mjs";
-import { VitestObjectionTransactionIsolator } from "./VitestObjectionTransactionIsolator-b973r9O1.mjs";
+import { DatabaseConnection, DatabaseFixtures, FixtureCreators, IsolationLevel } from "./VitestTransactionIsolator-DWDbnITQ.mjs";
+import { VitestObjectionTransactionIsolator } from "./VitestObjectionTransactionIsolator-lZUSz1w0.mjs";
 import { TestAPI } from "vitest";
 import { Knex } from "knex";
 
@@ -84,6 +84,55 @@ import { Knex } from "knex";
 declare function wrapVitestObjectionTransaction(api: TestAPI, conn: DatabaseConnection<Knex>, setup?: (trx: Knex.Transaction) => Promise<void>, level?: IsolationLevel): TestAPI<{
   trx: Knex.Transaction<any, any[]>;
 }>;
+/**
+ * Extends an Objection.js transaction-wrapped test with additional fixtures.
+ * Each fixture receives the transaction and can create dependencies like factories or repositories.
+ *
+ * @template Extended - The type of additional fixtures to provide
+ * @param wrappedTest - The base wrapped test from wrapVitestObjectionTransaction
+ * @param fixtures - Object mapping fixture names to creator functions
+ * @returns An extended test API with both trx and the additional fixtures
+ *
+ * @example
+ * ```typescript
+ * import { test } from 'vitest';
+ * import { wrapVitestObjectionTransaction, extendWithFixtures, ObjectionFactory } from '@geekmidas/testkit/objection';
+ * import { User } from './models';
+ *
+ * // Define your builders
+ * const builders = {
+ *   user: ObjectionFactory.createBuilder(User, ({ faker }) => ({
+ *     name: faker.person.fullName(),
+ *     email: faker.internet.email(),
+ *   })),
+ * };
+ *
+ * // Create base wrapped test
+ * const baseTest = wrapVitestObjectionTransaction(test, knex, createTestTables);
+ *
+ * // Extend with fixtures - each fixture receives the transaction
+ * const it = extendWithFixtures<{ factory: ObjectionFactory<typeof builders, {}> }>(
+ *   baseTest,
+ *   {
+ *     factory: (trx) => new ObjectionFactory(builders, {}, trx),
+ *   }
+ * );
+ *
+ * // Use in tests - both trx and factory are available
+ * it('should create user with factory', async ({ trx, factory }) => {
+ *   const user = await factory.insert('user', { name: 'Test User' });
+ *   expect(user.id).toBeDefined();
+ *
+ *   // Verify in database
+ *   const found = await User.query(trx).findById(user.id);
+ *   expect(found?.name).toBe('Test User');
+ * });
+ * ```
+ */
+declare function extendWithFixtures<Extended extends Record<string, unknown>, T extends ReturnType<TestAPI['extend']> = ReturnType<TestAPI['extend']>>(wrappedTest: T, fixtures: FixtureCreators<Knex.Transaction, Extended>): T & {
+  <C extends object>(name: string, fn: (context: DatabaseFixtures<Knex.Transaction<any, any[]>, object> & Extended & C) => Promise<void>): void;
+  <C extends object>(name: string, options: object, fn: (context: DatabaseFixtures<Knex.Transaction<any, any[]>, object> & Extended & C) => Promise<void>): void;
+};
 //#endregion
-export { IsolationLevel, ObjectionFactory, PostgresObjectionMigrator, VitestObjectionTransactionIsolator, wrapVitestObjectionTransaction };
+export { FakerFactory, FixtureCreators, IsolationLevel, ObjectionFactory, PostgresObjectionMigrator, VitestObjectionTransactionIsolator, extendWithFixtures, faker, wrapVitestObjectionTransaction };
 //# sourceMappingURL=objection.d.mts.map

package/dist/objection.mjs

@@ -1,10 +1,10 @@
 import "./Factory-z2m01hMj.mjs";
-import "./faker-BGKYFoCT.mjs";
-import { ObjectionFactory } from "./ObjectionFactory-8hebmnai.mjs";
+import { faker } from "./faker-BGKYFoCT.mjs";
+import { ObjectionFactory } from "./ObjectionFactory-zf2fLKrL.mjs";
 import "./PostgresMigrator-DbuJGAVy.mjs";
 import { PostgresObjectionMigrator } from "./PostgresObjectionMigrator-DPj2pOpX.mjs";
-import { IsolationLevel } from "./VitestTransactionIsolator-CskiiJbW.mjs";
-import { VitestObjectionTransactionIsolator } from "./VitestObjectionTransactionIsolator-BU-jXEhz.mjs";
+import { IsolationLevel, extendWithFixtures } from "./VitestTransactionIsolator-BIaMs4c2.mjs";
+import { VitestObjectionTransactionIsolator } from "./VitestObjectionTransactionIsolator-_EhJKu_O.mjs";
 
 //#region src/objection.ts
 /**
@@ -82,7 +82,55 @@ function wrapVitestObjectionTransaction(api, conn, setup, level = IsolationLevel
 	const wrapper = new VitestObjectionTransactionIsolator(api);
 	return wrapper.wrapVitestWithTransaction(conn, setup, level);
 }
+/**
+* Extends an Objection.js transaction-wrapped test with additional fixtures.
+* Each fixture receives the transaction and can create dependencies like factories or repositories.
+*
+* @template Extended - The type of additional fixtures to provide
+* @param wrappedTest - The base wrapped test from wrapVitestObjectionTransaction
+* @param fixtures - Object mapping fixture names to creator functions
+* @returns An extended test API with both trx and the additional fixtures
+*
+* @example
+* ```typescript
+* import { test } from 'vitest';
+* import { wrapVitestObjectionTransaction, extendWithFixtures, ObjectionFactory } from '@geekmidas/testkit/objection';
+* import { User } from './models';
+*
+* // Define your builders
+* const builders = {
+*   user: ObjectionFactory.createBuilder(User, ({ faker }) => ({
+*     name: faker.person.fullName(),
+*     email: faker.internet.email(),
+*   })),
+* };
+*
+* // Create base wrapped test
+* const baseTest = wrapVitestObjectionTransaction(test, knex, createTestTables);
+*
+* // Extend with fixtures - each fixture receives the transaction
+* const it = extendWithFixtures<{ factory: ObjectionFactory<typeof builders, {}> }>(
+*   baseTest,
+*   {
+*     factory: (trx) => new ObjectionFactory(builders, {}, trx),
+*   }
+* );
+*
+* // Use in tests - both trx and factory are available
+* it('should create user with factory', async ({ trx, factory }) => {
+*   const user = await factory.insert('user', { name: 'Test User' });
+*   expect(user.id).toBeDefined();
+*
+*   // Verify in database
+*   const found = await User.query(trx).findById(user.id);
+*   expect(found?.name).toBe('Test User');
+* });
+* ```
+*/
+function extendWithFixtures$1(wrappedTest, fixtures) {
+	return extendWithFixtures(wrappedTest, fixtures);
+}
 
 //#endregion
-export { IsolationLevel, ObjectionFactory, PostgresObjectionMigrator, VitestObjectionTransactionIsolator, wrapVitestObjectionTransaction };
+export { IsolationLevel, ObjectionFactory, PostgresObjectionMigrator, VitestObjectionTransactionIsolator, extendWithFixtures$1 as extendWithFixtures, faker, wrapVitestObjectionTransaction };
 //# sourceMappingURL=objection.mjs.map

package/dist/objection.mjs.map

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

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-B4oYx02C.mjs";
+import { DirectoryFixtures, itWithDir } from "../directory-BXavAeJZ.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-B4oYx02C.mjs";
+import { itWithDir } from "../directory-BXavAeJZ.mjs";
 export { itWithDir };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@geekmidas/testkit",
-  "version": "0.0.17",
+  "version": "0.1.0",
   "private": false,
   "type": "module",
   "exports": {
@@ -47,11 +47,15 @@
   },
   "dependencies": {
     "@faker-js/faker": "~9.9.0",
-    "@geekmidas/logger": "0.0.1"
+    "@geekmidas/logger": "0.1.0"
   },
   "devDependencies": {
     "@types/pg": "~8.15.4"
   },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/geekmidas/toolbox"
+  },
   "publishConfig": {
     "registry": "https://registry.npmjs.org/",
     "access": "public"
@@ -65,6 +69,6 @@
     "vitest": "~3.2.4",
     "@types/aws-lambda": ">=8.10.92",
     "better-auth": ">=1.3.34",
-    "@geekmidas/envkit": "0.0.7"
+    "@geekmidas/envkit": "0.1.0"
   }
 }

package/src/KyselyFactory.ts

@@ -25,13 +25,13 @@ import { type FakerFactory, faker } from './faker.ts';
  *
  * // Create builders
  * const builders = {
- *   user: KyselyFactory.createBuilder<Database, 'users'>('users', (attrs, factory, db, faker) => ({
+ *   user: KyselyFactory.createBuilder<Database, 'users'>('users', ({ attrs, faker }) => ({
  *     id: faker.string.uuid(),
  *     name: faker.person.fullName(),
  *     email: faker.internet.email(),
  *     ...attrs
  *   })),
- *   post: KyselyFactory.createBuilder<Database, 'posts'>('posts', (attrs) => ({
+ *   post: KyselyFactory.createBuilder<Database, 'posts'>('posts', ({ attrs }) => ({
  *     title: 'Test Post',
  *     content: 'Test content',
  *     ...attrs
@@ -88,15 +88,15 @@ export class KyselyFactory<
    * @template Result - The result type (defaults to Selectable of the table)
    *
    * @param table - The name of the database table
-   * @param item - Optional function to provide default values and transformations
+   * @param defaults - Optional function to provide default values (receives destructured context)
    * @param autoInsert - Whether to automatically insert the record (default: true)
    * @returns A builder function that creates and optionally inserts records
    *
    * @example
    * ```typescript
-   * // Create a simple builder with defaults
+   * // Create a simple builder with defaults - destructure only what you need
    * const userBuilder = KyselyFactory.createBuilder<DB, 'users'>('users',
-   *   (attrs, factory, db, faker) => ({
+   *   ({ attrs, faker }) => ({
    *     id: faker.string.uuid(),
    *     name: faker.person.fullName(),
    *     email: faker.internet.email(),
@@ -105,9 +105,17 @@ export class KyselyFactory<
    *   })
    * );
    *
+   * // Only need faker? Just destructure that
+   * const leaveTypeBuilder = KyselyFactory.createBuilder<DB, 'leaveTypes'>('leaveTypes',
+   *   ({ faker }) => ({
+   *     name: faker.helpers.arrayElement(['Annual', 'Sick', 'Maternity']),
+   *     code: faker.string.alpha({ length: 3, casing: 'upper' }),
+   *   })
+   * );
+   *
    * // Create a builder that doesn't auto-insert (useful for nested inserts)
    * const addressBuilder = KyselyFactory.createBuilder<DB, 'addresses'>('addresses',
-   *   (attrs) => ({
+   *   ({ attrs }) => ({
    *     street: '123 Main St',
    *     city: 'Anytown',
    *     ...attrs
@@ -126,12 +134,12 @@ export class KyselyFactory<
     Result = Selectable<DB[TableName]>,
   >(
     table: TableName,
-    item?: (
-      attrs: Attrs,
-      factory: Factory,
-      db: Kysely<DB>,
-      faker: FakerFactory,
-    ) =>
+    defaults?: (context: {
+      attrs: Attrs;
+      factory: Factory;
+      db: Kysely<DB>;
+      faker: FakerFactory;
+    }) =>
       | Partial<Insertable<DB[TableName]>>
       | Promise<Partial<Insertable<DB[TableName]>>>,
     autoInsert?: boolean,
@@ -145,15 +153,20 @@ export class KyselyFactory<
       attrs: Attrs,
       factory: Factory,
       db: Kysely<DB>,
-      faker: FakerFactory,
+      fakerInstance: FakerFactory,
     ) => {
       // Start with attributes
       let data: Partial<Insertable<DB[TableName]>> = { ...attrs };
 
       // Apply defaults
-      if (item) {
-        const defaults = await item(attrs, factory, db, faker);
-        data = { ...defaults, ...data };
+      if (defaults) {
+        const defaultValues = await defaults({
+          attrs,
+          factory,
+          db,
+          faker: fakerInstance,
+        });
+        data = { ...defaultValues, ...data };
       }
 
       // Handle insertion based on autoInsert flag

package/src/ObjectionFactory.ts

@@ -19,17 +19,17 @@ import { type FakerFactory, faker } from './faker.ts';
  *
  * // Create builders
  * const builders = {
- *   user: (attrs) => User.fromJson({
+ *   user: ObjectionFactory.createBuilder(User, ({ attrs, faker }) => ({
  *     id: faker.string.uuid(),
  *     name: faker.person.fullName(),
  *     email: faker.internet.email(),
  *     ...attrs
- *   }),
- *   post: (attrs) => Post.fromJson({
+ *   })),
+ *   post: ObjectionFactory.createBuilder(Post, ({ attrs }) => ({
  *     title: 'Test Post',
  *     content: 'Test content',
  *     ...attrs
- *   })
+ *   })),
  * };
  *
  * // Create factory instance
@@ -65,15 +65,15 @@ export class ObjectionFactory<
    * @template Result - The result type (defaults to the model instance)
    *
    * @param ModelClass - The Objection.js Model class
-   * @param item - Optional function to provide default values and transformations
+   * @param defaults - Optional function to provide default values (receives destructured context)
    * @param autoInsert - Whether to automatically insert the record (default: true)
    * @returns A builder function that creates and optionally inserts records
    *
    * @example
    * ```typescript
-   * // Create a simple builder with defaults
+   * // Create a simple builder with defaults - destructure only what you need
    * const userBuilder = ObjectionFactory.createBuilder(User,
-   *   (attrs, factory, db, faker) => ({
+   *   ({ attrs, faker }) => ({
    *     id: faker.string.uuid(),
    *     name: faker.person.fullName(),
    *     email: faker.internet.email(),
@@ -82,9 +82,17 @@ export class ObjectionFactory<
    *   })
    * );
    *
+   * // Only need faker? Just destructure that
+   * const leaveTypeBuilder = ObjectionFactory.createBuilder(LeaveType,
+   *   ({ faker }) => ({
+   *     name: faker.helpers.arrayElement(['Annual', 'Sick', 'Maternity']),
+   *     code: faker.string.alpha({ length: 3, casing: 'upper' }),
+   *   })
+   * );
+   *
    * // Create a builder that doesn't auto-insert (useful for nested inserts)
    * const addressBuilder = ObjectionFactory.createBuilder(Address,
-   *   (attrs) => ({
+   *   ({ attrs }) => ({
    *     street: '123 Main St',
    *     city: 'Anytown',
    *     ...attrs
@@ -94,7 +102,7 @@ export class ObjectionFactory<
    *
    * // Use with relations
    * const postBuilder = ObjectionFactory.createBuilder(Post,
-   *   async (attrs, factory) => ({
+   *   async ({ attrs, factory, faker }) => ({
    *     title: faker.lorem.sentence(),
    *     content: faker.lorem.paragraphs(),
    *     authorId: attrs.authorId || (await factory.insert('user')).id,
@@ -110,12 +118,14 @@ export class ObjectionFactory<
     Result = InstanceType<TModel>,
   >(
     ModelClass: TModel,
-    item?: (
-      attrs: Attrs,
-      factory: Factory,
-      db: Knex,
-      faker: FakerFactory,
-    ) => Partial<InstanceType<TModel>> | Promise<Partial<InstanceType<TModel>>>,
+    defaults?: (context: {
+      attrs: Attrs;
+      factory: Factory;
+      db: Knex;
+      faker: FakerFactory;
+    }) =>
+      | Partial<InstanceType<TModel>>
+      | Promise<Partial<InstanceType<TModel>>>,
     autoInsert?: boolean,
   ): (
     attrs: Attrs,
@@ -127,15 +137,20 @@ export class ObjectionFactory<
       attrs: Attrs,
       factory: Factory,
       db: Knex,
-      faker: FakerFactory,
+      fakerInstance: FakerFactory,
     ) => {
       // Start with attributes
       let data: Partial<InstanceType<TModel>> = { ...attrs };
 
       // Apply defaults
-      if (item) {
-        const defaults = await item(attrs, factory, db, faker);
-        data = { ...defaults, ...data };
+      if (defaults) {
+        const defaultValues = await defaults({
+          attrs,
+          factory,
+          db,
+          faker: fakerInstance,
+        });
+        data = { ...defaultValues, ...data };
       }
 
       // Create model instance

package/src/VitestTransactionIsolator.ts

@@ -5,8 +5,9 @@ import type { TestAPI } from 'vitest';
  * Used with Vitest's test.extend() API to inject transactions into tests.
  *
  * @template Transaction - The transaction type specific to the database driver
+ * @template Extended - Additional context properties provided by the extend function
  */
-export interface DatabaseFixtures<Transaction> {
+export interface DatabaseFixtures<Transaction, Extended = object> {
   /**
    * The database transaction available to the test.
    * All database operations should use this transaction to ensure proper rollback.
@@ -14,6 +15,31 @@ export interface DatabaseFixtures<Transaction> {
   trx: Transaction;
 }
 
+/**
+ * Combined fixtures type that merges the base transaction fixture with extended context.
+ */
+export type ExtendedDatabaseFixtures<
+  Transaction,
+  Extended = object,
+> = DatabaseFixtures<Transaction> & Extended;
+
+/**
+ * Function type for extending test context with additional properties.
+ * Receives the transaction and returns additional context to be merged with { trx }.
+ *
+ * @template Transaction - The transaction type
+ * @template Extended - The type of additional context to provide
+ *
+ * @example
+ * ```typescript
+ * const extendContext: ExtendContextFn<Transaction<DB>, { factory: KyselyFactory }> =
+ *   (trx) => ({ factory: new KyselyFactory(builders, seeds, trx) });
+ * ```
+ */
+export type ExtendContextFn<Transaction, Extended> = (
+  trx: Transaction,
+) => Extended | Promise<Extended>;
+
 /**
  * PostgreSQL transaction isolation levels.
  * Controls the visibility of concurrent transactions.
@@ -123,7 +149,7 @@ export abstract class VitestPostgresTransactionIsolator<TConn, Transaction> {
   ) {
     return this.api.extend<DatabaseFixtures<Transaction>>({
       // This fixture automatically provides a transaction to each test
-      trx: async ({}, use) => {
+      trx: async ({}, use: (value: Transaction) => Promise<void>) => {
         // Create a custom error class for rollback
         class TestRollback extends Error {
           constructor() {
@@ -168,3 +194,85 @@ export abstract class VitestPostgresTransactionIsolator<TConn, Transaction> {
 
 export type DatabaseConnectionFn<Conn> = () => Conn | Promise<Conn>;
 export type DatabaseConnection<Conn> = DatabaseConnectionFn<Conn>;
+
+/**
+ * Type for fixture creator functions that depend on the transaction.
+ * Each function receives the transaction and returns the fixture value.
+ */
+export type FixtureCreators<
+  Transaction,
+  Extended extends Record<string, unknown>,
+> = {
+  [K in keyof Extended]: (
+    trx: Transaction,
+  ) => Extended[K] | Promise<Extended[K]>;
+};
+
+/**
+ * Extends a wrapped test API with additional fixtures that depend on the transaction.
+ * This allows composing test context with factories, repositories, or other helpers.
+ *
+ * @template Transaction - The transaction type
+ * @template Extended - The type of additional context to provide
+ * @param wrappedTest - The base wrapped test from wrapVitestWithTransaction
+ * @param fixtures - Object mapping fixture names to creator functions
+ * @returns An extended test API with both trx and the additional fixtures
+ *
+ * @example
+ * ```typescript
+ * import { wrapVitestKyselyTransaction, extendWithFixtures } from '@geekmidas/testkit/kysely';
+ *
+ * // Create base wrapped test
+ * const baseTest = wrapVitestKyselyTransaction(test, db, createTestTables);
+ *
+ * // Extend with fixtures
+ * const it = extendWithFixtures(baseTest, {
+ *   factory: (trx) => new KyselyFactory(builders, seeds, trx),
+ *   userRepo: (trx) => new UserRepository(trx),
+ * });
+ *
+ * // Use in tests - trx and all fixtures are available
+ * it('should create user with factory', async ({ trx, factory, userRepo }) => {
+ *   const user = await factory.insert('user', { name: 'Test' });
+ *   expect(user).toBeDefined();
+ * });
+ * ```
+ */
+export function extendWithFixtures<
+  Transaction,
+  Extended extends Record<string, unknown>,
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  T extends ReturnType<TestAPI['extend']> = any,
+>(
+  wrappedTest: T,
+  fixtures: FixtureCreators<Transaction, Extended>,
+): T & {
+  <C extends object>(
+    name: string,
+    fn: (
+      context: DatabaseFixtures<Transaction> & Extended & C,
+    ) => Promise<void>,
+  ): void;
+  <C extends object>(
+    name: string,
+    options: object,
+    fn: (
+      context: DatabaseFixtures<Transaction> & Extended & C,
+    ) => Promise<void>,
+  ): void;
+} {
+  // Build fixture definitions for Vitest's extend API
+  const fixtureDefinitions: Record<string, any> = {};
+
+  for (const [key, creator] of Object.entries(fixtures)) {
+    fixtureDefinitions[key] = async (
+      { trx }: { trx: Transaction },
+      use: (value: unknown) => Promise<void>,
+    ) => {
+      const value = await (creator as (trx: Transaction) => unknown)(trx);
+      await use(value);
+    };
+  }
+
+  return (wrappedTest as any).extend(fixtureDefinitions);
+}

package/src/__tests__/KyselyFactory.spec.ts

@@ -24,7 +24,7 @@ describe('KyselyFactory', () => {
       async ({ trx }) => {
         const userBuilder = KyselyFactory.createBuilder<TestDatabase, 'users'>(
           'users',
-          async (attrs) => ({
+          async ({ attrs }) => ({
             name: 'John Doe',
             email: `user${Date.now()}@example.com`,
             createdAt: new Date(),
@@ -57,7 +57,7 @@ describe('KyselyFactory', () => {
       async ({ trx }) => {
         const userBuilder = KyselyFactory.createBuilder<TestDatabase, 'users'>(
           'users',
-          async (attrs) => ({
+          async ({ attrs }) => ({
             name: 'John Doe',
             email: `user${Date.now()}@example.com`,
             createdAt: new Date(),
@@ -98,7 +98,7 @@ describe('KyselyFactory', () => {
 
       const postBuilder = KyselyFactory.createBuilder<TestDatabase, 'posts'>(
         'posts',
-        async (attrs, factory) => {
+        async ({ attrs, factory }) => {
           // Create a user if userId not provided
           if (!attrs.userId) {
             const user = await factory.insert('user');
@@ -156,7 +156,7 @@ describe('KyselyFactory', () => {
       async ({ trx }) => {
         const userBuilder = KyselyFactory.createBuilder<TestDatabase, 'users'>(
           'users',
-          async (attrs) => ({
+          async () => ({
             name: 'John Doe',
             email: `user${Date.now()}-${Math.random()}@example.com`,
             createdAt: new Date(),
@@ -189,7 +189,7 @@ describe('KyselyFactory', () => {
       async ({ trx }) => {
         const userBuilder = KyselyFactory.createBuilder<TestDatabase, 'users'>(
           'users',
-          async (attrs) => ({
+          async () => ({
             email: `user${Date.now()}-${Math.random()}@example.com`,
             createdAt: new Date(),
           }),
@@ -233,7 +233,7 @@ describe('KyselyFactory', () => {
       let counter = 0;
       const userBuilder = KyselyFactory.createBuilder<TestDatabase, 'users'>(
         'users',
-        async (attrs) => {
+        async () => {
           // Simulate async operation
           await new Promise((resolve) => setTimeout(resolve, 10));
           counter++;
@@ -307,7 +307,7 @@ describe('KyselyFactory', () => {
       async ({ trx }) => {
         const userBuilder = KyselyFactory.createBuilder<TestDatabase, 'users'>(
           'users',
-          async (attrs) => ({
+          async ({ attrs }) => ({
             name: 'John Doe',
             email: `user${Date.now()}@example.com`,
             createdAt: new Date(),
@@ -364,7 +364,7 @@ describe('KyselyFactory', () => {
       async ({ trx }) => {
         const userBuilder = KyselyFactory.createBuilder<TestDatabase, 'users'>(
           'users',
-          async (attrs) => ({
+          async ({ attrs }) => ({
             name: 'John Doe',
             email: `user${Date.now()}@example.com`,
             createdAt: new Date(),
@@ -400,7 +400,7 @@ describe('KyselyFactory', () => {
       async ({ trx }) => {
         const userBuilder = KyselyFactory.createBuilder<TestDatabase, 'users'>(
           'users',
-          async (attrs) => ({
+          async ({ attrs }) => ({
             name: 'John Doe',
             email: `user${Date.now()}@example.com`,
             createdAt: new Date(),
@@ -409,7 +409,7 @@ describe('KyselyFactory', () => {
 
         const postBuilder = KyselyFactory.createBuilder<TestDatabase, 'posts'>(
           'posts',
-          async (attrs, factory) => {
+          async ({ factory }) => {
             const user = await factory.insert('user');
             return {
               title: 'Default Post',