@geekmidas/testkit 0.1.1 → 0.3.0

package/dist/{Factory-z2m01hMj.mjs → Factory-BFVnMMCC.mjs}

@@ -35,7 +35,7 @@ var Factory = class {
 	*
 	* @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;
 	* });
@@ -48,4 +48,4 @@ var Factory = class {
 
 //#endregion
 export { Factory };
-//# sourceMappingURL=Factory-z2m01hMj.mjs.map
+//# sourceMappingURL=Factory-BFVnMMCC.mjs.map

package/dist/Factory-BFVnMMCC.mjs.map

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

package/dist/{Factory-DE3hE0WO.d.mts → Factory-BcGJjLc8.d.mts}

@@ -1,4 +1,4 @@
-import { FakerFactory } from "./faker-D9gz7KjY.mjs";
+import { FakerFactory } from "./faker-DHh7xs4u.mjs";
 
 //#region src/Factory.d.ts
 
@@ -38,7 +38,7 @@ declare abstract class Factory<Builders extends Record<string, any>, Seeds exten
    *
    * @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;
    * });
@@ -67,7 +67,7 @@ declare abstract class Factory<Builders extends Record<string, any>, Seeds exten
    * @returns The result of the seed function
    * @param attrs - The attributes to pass to the seed function
    */
-  abstract seed<K extends keyof Seeds>(seedName: K, attrs?: Parameters<Seeds[K]>[0]): ReturnType<Seeds[K]>;
+  abstract seed<K extends keyof Seeds>(seedName: K, attrs?: ExtractSeedAttrs<Seeds[K]>): ReturnType<Seeds[K]>;
 }
 /**
  * Type definition for a factory builder function that can work with different database types.
@@ -106,15 +106,16 @@ type MixedFactoryBuilder<Attrs = any, Factory = any, Result = any, DB = any> = (
  * @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;
  *
@@ -126,7 +127,20 @@ type MixedFactoryBuilder<Attrs = any, Factory = any, Result = any, DB = any> = (
  *   };
  * ```
  */
-type FactorySeed<Attrs = any, Factory = any, Result = any, DB = any> = (attrs: Attrs, factory: Factory, db: DB) => Promise<Result>;
+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.
+ */
+type ExtractSeedAttrs<T> = T extends ((context: {
+  attrs: infer A;
+  factory: any;
+  db: any;
+}) => any) ? A : never;
 //#endregion
-export { Factory, FactorySeed, MixedFactoryBuilder };
-//# sourceMappingURL=Factory-DE3hE0WO.d.mts.map
+export { ExtractSeedAttrs, Factory, FactorySeed, MixedFactoryBuilder };
+//# sourceMappingURL=Factory-BcGJjLc8.d.mts.map

package/dist/{Factory-WMhTNZ9S.cjs → Factory-BhjUOBWN.cjs}

@@ -36,7 +36,7 @@ var Factory = class {
 	*
 	* @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;
 	* });
@@ -54,4 +54,4 @@ Object.defineProperty(exports, 'Factory', {
     return Factory;
   }
 });
-//# sourceMappingURL=Factory-WMhTNZ9S.cjs.map
+//# sourceMappingURL=Factory-BhjUOBWN.cjs.map

package/dist/Factory-BhjUOBWN.cjs.map

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

package/dist/{Factory-pNV7ZQ7-.d.cts → Factory-IdfEkOeT.d.cts}

@@ -1,4 +1,4 @@
-import { FakerFactory } from "./faker-BSH1EMtg.cjs";
+import { FakerFactory } from "./faker-CbYiF-8_.cjs";
 
 //#region src/Factory.d.ts
 
@@ -38,7 +38,7 @@ declare abstract class Factory<Builders extends Record<string, any>, Seeds exten
    *
    * @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;
    * });
@@ -67,7 +67,7 @@ declare abstract class Factory<Builders extends Record<string, any>, Seeds exten
    * @returns The result of the seed function
    * @param attrs - The attributes to pass to the seed function
    */
-  abstract seed<K extends keyof Seeds>(seedName: K, attrs?: Parameters<Seeds[K]>[0]): ReturnType<Seeds[K]>;
+  abstract seed<K extends keyof Seeds>(seedName: K, attrs?: ExtractSeedAttrs<Seeds[K]>): ReturnType<Seeds[K]>;
 }
 /**
  * Type definition for a factory builder function that can work with different database types.
@@ -106,15 +106,16 @@ type MixedFactoryBuilder<Attrs = any, Factory = any, Result = any, DB = any> = (
  * @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;
  *
@@ -126,7 +127,20 @@ type MixedFactoryBuilder<Attrs = any, Factory = any, Result = any, DB = any> = (
  *   };
  * ```
  */
-type FactorySeed<Attrs = any, Factory = any, Result = any, DB = any> = (attrs: Attrs, factory: Factory, db: DB) => Promise<Result>;
+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.
+ */
+type ExtractSeedAttrs<T> = T extends ((context: {
+  attrs: infer A;
+  factory: any;
+  db: any;
+}) => any) ? A : never;
 //#endregion
-export { Factory, FactorySeed, MixedFactoryBuilder };
-//# sourceMappingURL=Factory-pNV7ZQ7-.d.cts.map
+export { ExtractSeedAttrs, Factory, FactorySeed, MixedFactoryBuilder };
+//# sourceMappingURL=Factory-IdfEkOeT.d.cts.map

package/dist/Factory.cjs

@@ -1,3 +1,3 @@
-const require_Factory = require('./Factory-WMhTNZ9S.cjs');
+const require_Factory = require('./Factory-BhjUOBWN.cjs');
 
 exports.Factory = require_Factory.Factory;

package/dist/Factory.d.cts

@@ -1,3 +1,3 @@
-import "./faker-BSH1EMtg.cjs";
-import { Factory, FactorySeed, MixedFactoryBuilder } from "./Factory-pNV7ZQ7-.cjs";
-export { Factory, FactorySeed, MixedFactoryBuilder };
+import "./faker-CbYiF-8_.cjs";
+import { ExtractSeedAttrs, Factory, FactorySeed, MixedFactoryBuilder } from "./Factory-IdfEkOeT.cjs";
+export { ExtractSeedAttrs, Factory, FactorySeed, MixedFactoryBuilder };

package/dist/Factory.d.mts

@@ -1,3 +1,3 @@
-import "./faker-D9gz7KjY.mjs";
-import { Factory, FactorySeed, MixedFactoryBuilder } from "./Factory-DE3hE0WO.mjs";
-export { Factory, FactorySeed, MixedFactoryBuilder };
+import "./faker-DHh7xs4u.mjs";
+import { ExtractSeedAttrs, Factory, FactorySeed, MixedFactoryBuilder } from "./Factory-BcGJjLc8.mjs";
+export { ExtractSeedAttrs, Factory, FactorySeed, MixedFactoryBuilder };

package/dist/Factory.mjs

@@ -1,3 +1,3 @@
-import { Factory } from "./Factory-z2m01hMj.mjs";
+import { Factory } from "./Factory-BFVnMMCC.mjs";
 
 export { Factory };

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

@@ -1,4 +1,4 @@
-const require_Factory = require('./Factory-WMhTNZ9S.cjs');
+const require_Factory = require('./Factory-BhjUOBWN.cjs');
 const require_faker = require('./faker-B14IEMIN.cjs');
 
 //#region src/KyselyFactory.ts
@@ -46,8 +46,21 @@ var KyselyFactory = class extends require_Factory.Factory {
 	* 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(seedFn) {
 		return require_Factory.Factory.createSeed(seedFn);
@@ -215,7 +228,11 @@ var KyselyFactory = class extends require_Factory.Factory {
 	*/
 	seed(seedName, attrs) {
 		if (!(seedName in this.seeds)) throw new Error(`Seed "${seedName}" is not registered in this factory. Make sure it is correct and registered in src/test/setup.ts`);
-		return this.seeds[seedName](attrs || {}, this, this.db);
+		return this.seeds[seedName]({
+			attrs: attrs || {},
+			factory: this,
+			db: this.db
+		});
 	}
 };
 
@@ -226,4 +243,4 @@ Object.defineProperty(exports, 'KyselyFactory', {
     return KyselyFactory;
   }
 });
-//# sourceMappingURL=KyselyFactory-DaaCykWP.cjs.map
+//# sourceMappingURL=KyselyFactory-BFqVIn_0.cjs.map

package/dist/KyselyFactory-BFqVIn_0.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"KyselyFactory-BFqVIn_0.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?: ExtractSeedAttrs<Seeds[K]>"],"sources":["../src/KyselyFactory.ts"],"sourcesContent":["import type {\n  ControlledTransaction,\n  Insertable,\n  Kysely,\n  Selectable,\n} from 'kysely';\nimport { type ExtractSeedAttrs, 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 (receives { attrs, factory, db } object)\n   * @returns The same seed function with proper typing\n   *\n   * @example\n   * ```typescript\n   * const seeds = {\n   *   userWithPosts: KyselyFactory.createSeed(\n   *     async ({ attrs, factory }) => {\n   *       const user = await factory.insert('user', attrs);\n   *       await factory.insertMany(3, 'post', { userId: user.id });\n   *       return user;\n   *     },\n   *   ),\n   * };\n   * ```\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?: ExtractSeedAttrs<Seeds[K]>,\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]({\n      attrs: attrs || {},\n      factory: this,\n      db: this.db,\n    });\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+CA,IAAa,gBAAb,cAIUA,wBAAyB;;;;;;;;;;;;;;;;;;;;;;CAsBjC,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;GAC1B,OAAO,SAAS,CAAE;GAClB,SAAS;GACT,IAAI,KAAK;EACV,EAAC;CACH;AACF"}

package/dist/{KyselyFactory-CPZTUuMB.d.cts → KyselyFactory-Cj-EultY.d.mts}

@@ -1,5 +1,5 @@
-import { FakerFactory } from "./faker-BSH1EMtg.cjs";
-import { Factory, FactorySeed } from "./Factory-pNV7ZQ7-.cjs";
+import { FakerFactory } from "./faker-DHh7xs4u.mjs";
+import { ExtractSeedAttrs, Factory, FactorySeed } from "./Factory-BcGJjLc8.mjs";
 import { ControlledTransaction, Insertable, Kysely, Selectable } from "kysely";
 
 //#region src/KyselyFactory.d.ts
@@ -51,8 +51,21 @@ declare class KyselyFactory<DB, Builders extends Record<string, any>, Seeds exte
    * 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;
   /**
@@ -207,8 +220,8 @@ declare class KyselyFactory<DB, Builders extends Record<string, any>, Seeds exte
    * expect(company.departments).toHaveLength(3);
    * ```
    */
-  seed<K extends keyof Seeds>(seedName: K, attrs?: Parameters<Seeds[K]>[0]): ReturnType<Seeds[K]>;
+  seed<K extends keyof Seeds>(seedName: K, attrs?: ExtractSeedAttrs<Seeds[K]>): ReturnType<Seeds[K]>;
 }
 //#endregion
 export { KyselyFactory };
-//# sourceMappingURL=KyselyFactory-CPZTUuMB.d.cts.map
+//# sourceMappingURL=KyselyFactory-Cj-EultY.d.mts.map

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

@@ -1,4 +1,4 @@
-import { Factory } from "./Factory-z2m01hMj.mjs";
+import { Factory } from "./Factory-BFVnMMCC.mjs";
 import { faker } from "./faker-BGKYFoCT.mjs";
 
 //#region src/KyselyFactory.ts
@@ -46,8 +46,21 @@ var KyselyFactory = class extends Factory {
 	* 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(seedFn) {
 		return Factory.createSeed(seedFn);
@@ -215,10 +228,14 @@ var KyselyFactory = class extends Factory {
 	*/
 	seed(seedName, attrs) {
 		if (!(seedName in this.seeds)) throw new Error(`Seed "${seedName}" is not registered in this factory. Make sure it is correct and registered in src/test/setup.ts`);
-		return this.seeds[seedName](attrs || {}, this, this.db);
+		return this.seeds[seedName]({
+			attrs: attrs || {},
+			factory: this,
+			db: this.db
+		});
 	}
 };
 
 //#endregion
 export { KyselyFactory };
-//# sourceMappingURL=KyselyFactory-CXY5gJk2.mjs.map
+//# sourceMappingURL=KyselyFactory-DMswpwji.mjs.map

package/dist/KyselyFactory-DMswpwji.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"KyselyFactory-DMswpwji.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?: ExtractSeedAttrs<Seeds[K]>"],"sources":["../src/KyselyFactory.ts"],"sourcesContent":["import type {\n  ControlledTransaction,\n  Insertable,\n  Kysely,\n  Selectable,\n} from 'kysely';\nimport { type ExtractSeedAttrs, 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 (receives { attrs, factory, db } object)\n   * @returns The same seed function with proper typing\n   *\n   * @example\n   * ```typescript\n   * const seeds = {\n   *   userWithPosts: KyselyFactory.createSeed(\n   *     async ({ attrs, factory }) => {\n   *       const user = await factory.insert('user', attrs);\n   *       await factory.insertMany(3, 'post', { userId: user.id });\n   *       return user;\n   *     },\n   *   ),\n   * };\n   * ```\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?: ExtractSeedAttrs<Seeds[K]>,\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]({\n      attrs: attrs || {},\n      factory: this,\n      db: this.db,\n    });\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+CA,IAAa,gBAAb,cAIU,QAAyB;;;;;;;;;;;;;;;;;;;;;;CAsBjC,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;GAC1B,OAAO,SAAS,CAAE;GAClB,SAAS;GACT,IAAI,KAAK;EACV,EAAC;CACH;AACF"}

package/dist/{KyselyFactory-RAyvZ8Cj.d.mts → KyselyFactory-Dxhi_ZkA.d.cts}

@@ -1,5 +1,5 @@
-import { FakerFactory } from "./faker-D9gz7KjY.mjs";
-import { Factory, FactorySeed } from "./Factory-DE3hE0WO.mjs";
+import { FakerFactory } from "./faker-CbYiF-8_.cjs";
+import { ExtractSeedAttrs, Factory, FactorySeed } from "./Factory-IdfEkOeT.cjs";
 import { ControlledTransaction, Insertable, Kysely, Selectable } from "kysely";
 
 //#region src/KyselyFactory.d.ts
@@ -51,8 +51,21 @@ declare class KyselyFactory<DB, Builders extends Record<string, any>, Seeds exte
    * 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;
   /**
@@ -207,8 +220,8 @@ declare class KyselyFactory<DB, Builders extends Record<string, any>, Seeds exte
    * expect(company.departments).toHaveLength(3);
    * ```
    */
-  seed<K extends keyof Seeds>(seedName: K, attrs?: Parameters<Seeds[K]>[0]): ReturnType<Seeds[K]>;
+  seed<K extends keyof Seeds>(seedName: K, attrs?: ExtractSeedAttrs<Seeds[K]>): ReturnType<Seeds[K]>;
 }
 //#endregion
 export { KyselyFactory };
-//# sourceMappingURL=KyselyFactory-RAyvZ8Cj.d.mts.map
+//# sourceMappingURL=KyselyFactory-Dxhi_ZkA.d.cts.map

package/dist/KyselyFactory.cjs

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

package/dist/KyselyFactory.d.cts

@@ -1,4 +1,4 @@
-import "./faker-BSH1EMtg.cjs";
-import "./Factory-pNV7ZQ7-.cjs";
-import { KyselyFactory } from "./KyselyFactory-CPZTUuMB.cjs";
+import "./faker-CbYiF-8_.cjs";
+import "./Factory-IdfEkOeT.cjs";
+import { KyselyFactory } from "./KyselyFactory-Dxhi_ZkA.cjs";
 export { KyselyFactory };

package/dist/KyselyFactory.d.mts

@@ -1,4 +1,4 @@
-import "./faker-D9gz7KjY.mjs";
-import "./Factory-DE3hE0WO.mjs";
-import { KyselyFactory } from "./KyselyFactory-RAyvZ8Cj.mjs";
+import "./faker-DHh7xs4u.mjs";
+import "./Factory-BcGJjLc8.mjs";
+import { KyselyFactory } from "./KyselyFactory-Cj-EultY.mjs";
 export { KyselyFactory };

package/dist/KyselyFactory.mjs

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

package/dist/{ObjectionFactory-BlBicEia.d.mts → ObjectionFactory-BRAkAByP.d.cts}

@@ -1,5 +1,5 @@
-import { FakerFactory } from "./faker-D9gz7KjY.mjs";
-import { Factory, FactorySeed } from "./Factory-DE3hE0WO.mjs";
+import { FakerFactory } from "./faker-CbYiF-8_.cjs";
+import { ExtractSeedAttrs, Factory, FactorySeed } from "./Factory-IdfEkOeT.cjs";
 import { Knex } from "knex";
 import { Model } from "objection";
 
@@ -50,8 +50,21 @@ declare class ObjectionFactory<Builders extends Record<string, any>, Seeds exten
    * 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;
   /**
@@ -220,8 +233,8 @@ declare class ObjectionFactory<Builders extends Record<string, any>, Seeds exten
    *   .withGraphFetched('[departments.employees]');
    * ```
    */
-  seed<K extends keyof Seeds>(seedName: K, attrs?: Parameters<Seeds[K]>[0]): ReturnType<Seeds[K]>;
+  seed<K extends keyof Seeds>(seedName: K, attrs?: ExtractSeedAttrs<Seeds[K]>): ReturnType<Seeds[K]>;
 }
 //#endregion
 export { ObjectionFactory };
-//# sourceMappingURL=ObjectionFactory-BlBicEia.d.mts.map
+//# sourceMappingURL=ObjectionFactory-BRAkAByP.d.cts.map

package/dist/{ObjectionFactory-Eb04AOnv.cjs → ObjectionFactory-BeFBYcan.cjs}

@@ -1,4 +1,4 @@
-const require_Factory = require('./Factory-WMhTNZ9S.cjs');
+const require_Factory = require('./Factory-BhjUOBWN.cjs');
 const require_faker = require('./faker-B14IEMIN.cjs');
 
 //#region src/ObjectionFactory.ts
@@ -44,8 +44,21 @@ var ObjectionFactory = class extends require_Factory.Factory {
 	* 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(seedFn) {
 		return require_Factory.Factory.createSeed(seedFn);
@@ -241,7 +254,11 @@ var ObjectionFactory = class extends require_Factory.Factory {
 	*/
 	seed(seedName, attrs) {
 		if (!(seedName in this.seeds)) throw new Error(`Seed "${seedName}" is not registered in this factory. Make sure it is correct and registered in src/test/setup.ts`);
-		return this.seeds[seedName](attrs || {}, this, this.db);
+		return this.seeds[seedName]({
+			attrs: attrs || {},
+			factory: this,
+			db: this.db
+		});
 	}
 };
 
@@ -252,4 +269,4 @@ Object.defineProperty(exports, 'ObjectionFactory', {
     return ObjectionFactory;
   }
 });
-//# sourceMappingURL=ObjectionFactory-Eb04AOnv.cjs.map
+//# sourceMappingURL=ObjectionFactory-BeFBYcan.cjs.map