@geekmidas/testkit 0.0.16 → 0.1.0

package/dist/{KyselyFactory-DRQ83r0o.d.cts → KyselyFactory-BFygzOlO.d.cts}

@@ -22,13 +22,13 @@ import { ControlledTransaction, Insertable, Kysely, Selectable } from "kysely";
  *
  * // 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
@@ -74,15 +74,15 @@ declare class KyselyFactory<DB, Builders extends Record<string, any>, Seeds exte
    * @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(),
@@ -91,9 +91,17 @@ declare class KyselyFactory<DB, Builders extends Record<string, any>, Seeds exte
    *   })
    * );
    *
+   * // 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
@@ -102,7 +110,12 @@ declare class KyselyFactory<DB, Builders extends Record<string, any>, Seeds exte
    * );
    * ```
    */
-  static createBuilder<DB, TableName extends keyof DB & string, Attrs extends Partial<Insertable<DB[TableName]>> = Partial<Insertable<DB[TableName]>>, Factory = any, Result = Selectable<DB[TableName]>>(table: TableName, item?: (attrs: Attrs, factory: Factory, db: Kysely<DB>, faker: FakerFactory) => Partial<Insertable<DB[TableName]>> | Promise<Partial<Insertable<DB[TableName]>>>, autoInsert?: boolean): (attrs: Attrs, factory: Factory, db: Kysely<DB>, faker: FakerFactory) => Promise<Result>;
+  static createBuilder<DB, TableName extends keyof DB & string, Attrs extends Partial<Insertable<DB[TableName]>> = Partial<Insertable<DB[TableName]>>, Factory = any, Result = Selectable<DB[TableName]>>(table: TableName, defaults?: (context: {
+    attrs: Attrs;
+    factory: Factory;
+    db: Kysely<DB>;
+    faker: FakerFactory;
+  }) => Partial<Insertable<DB[TableName]>> | Promise<Partial<Insertable<DB[TableName]>>>, autoInsert?: boolean): (attrs: Attrs, factory: Factory, db: Kysely<DB>, faker: FakerFactory) => Promise<Result>;
   /**
    * Inserts a single record into the database using the specified builder.
    * The builder function is responsible for generating the record data with defaults
@@ -198,4 +211,4 @@ declare class KyselyFactory<DB, Builders extends Record<string, any>, Seeds exte
 }
 //#endregion
 export { KyselyFactory };
-//# sourceMappingURL=KyselyFactory-DRQ83r0o.d.cts.map
+//# sourceMappingURL=KyselyFactory-BFygzOlO.d.cts.map

package/dist/{KyselyFactory-Cx3sezwH.d.mts → KyselyFactory-BTdygZ-i.d.mts}

@@ -22,13 +22,13 @@ import { ControlledTransaction, Insertable, Kysely, Selectable } from "kysely";
  *
  * // 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
@@ -74,15 +74,15 @@ declare class KyselyFactory<DB, Builders extends Record<string, any>, Seeds exte
    * @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(),
@@ -91,9 +91,17 @@ declare class KyselyFactory<DB, Builders extends Record<string, any>, Seeds exte
    *   })
    * );
    *
+   * // 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
@@ -102,7 +110,12 @@ declare class KyselyFactory<DB, Builders extends Record<string, any>, Seeds exte
    * );
    * ```
    */
-  static createBuilder<DB, TableName extends keyof DB & string, Attrs extends Partial<Insertable<DB[TableName]>> = Partial<Insertable<DB[TableName]>>, Factory = any, Result = Selectable<DB[TableName]>>(table: TableName, item?: (attrs: Attrs, factory: Factory, db: Kysely<DB>, faker: FakerFactory) => Partial<Insertable<DB[TableName]>> | Promise<Partial<Insertable<DB[TableName]>>>, autoInsert?: boolean): (attrs: Attrs, factory: Factory, db: Kysely<DB>, faker: FakerFactory) => Promise<Result>;
+  static createBuilder<DB, TableName extends keyof DB & string, Attrs extends Partial<Insertable<DB[TableName]>> = Partial<Insertable<DB[TableName]>>, Factory = any, Result = Selectable<DB[TableName]>>(table: TableName, defaults?: (context: {
+    attrs: Attrs;
+    factory: Factory;
+    db: Kysely<DB>;
+    faker: FakerFactory;
+  }) => Partial<Insertable<DB[TableName]>> | Promise<Partial<Insertable<DB[TableName]>>>, autoInsert?: boolean): (attrs: Attrs, factory: Factory, db: Kysely<DB>, faker: FakerFactory) => Promise<Result>;
   /**
    * Inserts a single record into the database using the specified builder.
    * The builder function is responsible for generating the record data with defaults
@@ -198,4 +211,4 @@ declare class KyselyFactory<DB, Builders extends Record<string, any>, Seeds exte
 }
 //#endregion
 export { KyselyFactory };
-//# sourceMappingURL=KyselyFactory-Cx3sezwH.d.mts.map
+//# sourceMappingURL=KyselyFactory-BTdygZ-i.d.mts.map

package/dist/{KyselyFactory-BcYkC0t2.mjs → KyselyFactory-CXY5gJk2.mjs}

@@ -20,13 +20,13 @@ import { faker } from "./faker-BGKYFoCT.mjs";
 *
 * // 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
@@ -76,15 +76,15 @@ var KyselyFactory = class extends Factory {
 	* @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(),
@@ -93,9 +93,17 @@ var KyselyFactory = class extends Factory {
 	*   })
 	* );
 	*
+	* // 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
@@ -104,13 +112,18 @@ var KyselyFactory = class extends Factory {
 	* );
 	* ```
 	*/
-	static createBuilder(table, item, autoInsert) {
-		return async (attrs, factory, db, faker$1) => {
+	static createBuilder(table, defaults, autoInsert) {
+		return async (attrs, factory, db, fakerInstance) => {
 			let data = { ...attrs };
-			if (item) {
-				const defaults = await item(attrs, factory, db, faker$1);
+			if (defaults) {
+				const defaultValues = await defaults({
+					attrs,
+					factory,
+					db,
+					faker: fakerInstance
+				});
 				data = {
-					...defaults,
+					...defaultValues,
 					...data
 				};
 			}
@@ -208,4 +221,4 @@ var KyselyFactory = class extends Factory {
 
 //#endregion
 export { KyselyFactory };
-//# sourceMappingURL=KyselyFactory-BcYkC0t2.mjs.map
+//# sourceMappingURL=KyselyFactory-CXY5gJk2.mjs.map

package/dist/KyselyFactory-CXY5gJk2.mjs.map

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

package/dist/{KyselyFactory-Cf0o2YxO.cjs → KyselyFactory-DaaCykWP.cjs}

@@ -20,13 +20,13 @@ const require_faker = require('./faker-B14IEMIN.cjs');
 *
 * // 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
@@ -76,15 +76,15 @@ var KyselyFactory = class extends require_Factory.Factory {
 	* @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(),
@@ -93,9 +93,17 @@ var KyselyFactory = class extends require_Factory.Factory {
 	*   })
 	* );
 	*
+	* // 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
@@ -104,13 +112,18 @@ var KyselyFactory = class extends require_Factory.Factory {
 	* );
 	* ```
 	*/
-	static createBuilder(table, item, autoInsert) {
-		return async (attrs, factory, db, faker$1) => {
+	static createBuilder(table, defaults, autoInsert) {
+		return async (attrs, factory, db, fakerInstance) => {
 			let data = { ...attrs };
-			if (item) {
-				const defaults = await item(attrs, factory, db, faker$1);
+			if (defaults) {
+				const defaultValues = await defaults({
+					attrs,
+					factory,
+					db,
+					faker: fakerInstance
+				});
 				data = {
-					...defaults,
+					...defaultValues,
 					...data
 				};
 			}
@@ -213,4 +226,4 @@ Object.defineProperty(exports, 'KyselyFactory', {
     return KyselyFactory;
   }
 });
-//# sourceMappingURL=KyselyFactory-Cf0o2YxO.cjs.map
+//# sourceMappingURL=KyselyFactory-DaaCykWP.cjs.map

package/dist/KyselyFactory-DaaCykWP.cjs.map

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

package/dist/KyselyFactory.cjs

@@ -1,5 +1,5 @@
 require('./Factory-WMhTNZ9S.cjs');
 require('./faker-B14IEMIN.cjs');
-const require_KyselyFactory = require('./KyselyFactory-Cf0o2YxO.cjs');
+const require_KyselyFactory = require('./KyselyFactory-DaaCykWP.cjs');
 
 exports.KyselyFactory = require_KyselyFactory.KyselyFactory;

package/dist/KyselyFactory.d.cts

@@ -1,4 +1,4 @@
 import "./faker-Cg76aFNO.cjs";
 import "./Factory-BZ8uMoXl.cjs";
-import { KyselyFactory } from "./KyselyFactory-DRQ83r0o.cjs";
+import { KyselyFactory } from "./KyselyFactory-BFygzOlO.cjs";
 export { KyselyFactory };

package/dist/KyselyFactory.d.mts

@@ -1,4 +1,4 @@
 import "./faker-DHh7xs4u.mjs";
 import "./Factory-Cmr3s3-s.mjs";
-import { KyselyFactory } from "./KyselyFactory-Cx3sezwH.mjs";
+import { KyselyFactory } from "./KyselyFactory-BTdygZ-i.mjs";
 export { KyselyFactory };

package/dist/KyselyFactory.mjs

@@ -1,5 +1,5 @@
 import "./Factory-z2m01hMj.mjs";
 import "./faker-BGKYFoCT.mjs";
-import { KyselyFactory } from "./KyselyFactory-BcYkC0t2.mjs";
+import { KyselyFactory } from "./KyselyFactory-CXY5gJk2.mjs";
 
 export { KyselyFactory };

package/dist/{ObjectionFactory-C-59Hjwj.d.mts → ObjectionFactory-BagGjikT.d.mts}

@@ -21,17 +21,17 @@ import { Model } from "objection";
  *
  * // 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
@@ -64,15 +64,15 @@ declare class ObjectionFactory<Builders extends Record<string, any>, Seeds exten
    * @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(),
@@ -81,9 +81,17 @@ declare class ObjectionFactory<Builders extends Record<string, any>, Seeds exten
    *   })
    * );
    *
+   * // 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
@@ -93,7 +101,7 @@ declare class ObjectionFactory<Builders extends Record<string, any>, Seeds exten
    *
    * // 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,
@@ -102,7 +110,12 @@ declare class ObjectionFactory<Builders extends Record<string, any>, Seeds exten
    * );
    * ```
    */
-  static createBuilder<TModel extends typeof Model, Attrs extends Partial<InstanceType<TModel>> = Partial<InstanceType<TModel>>, Factory = any, Result = InstanceType<TModel>>(ModelClass: TModel, item?: (attrs: Attrs, factory: Factory, db: Knex, faker: FakerFactory) => Partial<InstanceType<TModel>> | Promise<Partial<InstanceType<TModel>>>, autoInsert?: boolean): (attrs: Attrs, factory: Factory, db: Knex, faker: FakerFactory) => Promise<Result>;
+  static createBuilder<TModel extends typeof Model, Attrs extends Partial<InstanceType<TModel>> = Partial<InstanceType<TModel>>, Factory = any, Result = InstanceType<TModel>>(ModelClass: TModel, defaults?: (context: {
+    attrs: Attrs;
+    factory: Factory;
+    db: Knex;
+    faker: FakerFactory;
+  }) => Partial<InstanceType<TModel>> | Promise<Partial<InstanceType<TModel>>>, autoInsert?: boolean): (attrs: Attrs, factory: Factory, db: Knex, faker: FakerFactory) => Promise<Result>;
   /**
    * Creates a new ObjectionFactory instance.
    *
@@ -211,4 +224,4 @@ declare class ObjectionFactory<Builders extends Record<string, any>, Seeds exten
 }
 //#endregion
 export { ObjectionFactory };
-//# sourceMappingURL=ObjectionFactory-C-59Hjwj.d.mts.map
+//# sourceMappingURL=ObjectionFactory-BagGjikT.d.mts.map

package/dist/{ObjectionFactory-C4X78k0B.d.cts → ObjectionFactory-CeSIN3kZ.d.cts}

@@ -21,17 +21,17 @@ import { Model } from "objection";
  *
  * // 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
@@ -64,15 +64,15 @@ declare class ObjectionFactory<Builders extends Record<string, any>, Seeds exten
    * @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(),
@@ -81,9 +81,17 @@ declare class ObjectionFactory<Builders extends Record<string, any>, Seeds exten
    *   })
    * );
    *
+   * // 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
@@ -93,7 +101,7 @@ declare class ObjectionFactory<Builders extends Record<string, any>, Seeds exten
    *
    * // 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,
@@ -102,7 +110,12 @@ declare class ObjectionFactory<Builders extends Record<string, any>, Seeds exten
    * );
    * ```
    */
-  static createBuilder<TModel extends typeof Model, Attrs extends Partial<InstanceType<TModel>> = Partial<InstanceType<TModel>>, Factory = any, Result = InstanceType<TModel>>(ModelClass: TModel, item?: (attrs: Attrs, factory: Factory, db: Knex, faker: FakerFactory) => Partial<InstanceType<TModel>> | Promise<Partial<InstanceType<TModel>>>, autoInsert?: boolean): (attrs: Attrs, factory: Factory, db: Knex, faker: FakerFactory) => Promise<Result>;
+  static createBuilder<TModel extends typeof Model, Attrs extends Partial<InstanceType<TModel>> = Partial<InstanceType<TModel>>, Factory = any, Result = InstanceType<TModel>>(ModelClass: TModel, defaults?: (context: {
+    attrs: Attrs;
+    factory: Factory;
+    db: Knex;
+    faker: FakerFactory;
+  }) => Partial<InstanceType<TModel>> | Promise<Partial<InstanceType<TModel>>>, autoInsert?: boolean): (attrs: Attrs, factory: Factory, db: Knex, faker: FakerFactory) => Promise<Result>;
   /**
    * Creates a new ObjectionFactory instance.
    *
@@ -211,4 +224,4 @@ declare class ObjectionFactory<Builders extends Record<string, any>, Seeds exten
 }
 //#endregion
 export { ObjectionFactory };
-//# sourceMappingURL=ObjectionFactory-C4X78k0B.d.cts.map
+//# sourceMappingURL=ObjectionFactory-CeSIN3kZ.d.cts.map