@geekmidas/testkit 0.0.10 → 0.0.11

package/dist/Factory-B9LP1L18.d.cts

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

package/dist/Factory-DiZSNxC0.d.mts

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

package/dist/Factory.d.cts

@@ -0,0 +1,3 @@
+import "./faker-DAiFK3T3.cjs";
+import { Factory, FactorySeed, MixedFactoryBuilder } from "./Factory-B9LP1L18.cjs";
+export { Factory, FactorySeed, MixedFactoryBuilder };

package/dist/Factory.d.mts

@@ -0,0 +1,3 @@
+import "./faker-nN9Ki6fn.mjs";
+import { Factory, FactorySeed, MixedFactoryBuilder } from "./Factory-DiZSNxC0.mjs";
+export { Factory, FactorySeed, MixedFactoryBuilder };

package/dist/KyselyFactory-B-zlLbov.d.mts

@@ -0,0 +1,200 @@
+import { FakerFactory } from "./faker-nN9Ki6fn.mjs";
+import { Factory, FactorySeed } from "./Factory-DiZSNxC0.mjs";
+import { ControlledTransaction, Insertable, Kysely, Selectable } from "kysely";
+
+//#region src/KyselyFactory.d.ts
+
+/**
+ * Factory implementation for Kysely ORM, providing test data creation utilities.
+ * Extends the base Factory class with Kysely-specific database operations.
+ *
+ * @template DB - The database schema type
+ * @template Builders - Record of builder functions for creating entities
+ * @template Seeds - Record of seed functions for complex test scenarios
+ *
+ * @example
+ * ```typescript
+ * // Define your database schema
+ * interface Database {
+ *   users: UsersTable;
+ *   posts: PostsTable;
+ * }
+ *
+ * // Create builders
+ * const builders = {
+ *   user: KyselyFactory.createBuilder<Database, 'users'>('users', (attrs, factory, db, faker) => ({
+ *     id: faker.string.uuid(),
+ *     name: faker.person.fullName(),
+ *     email: faker.internet.email(),
+ *     ...attrs
+ *   })),
+ *   post: KyselyFactory.createBuilder<Database, 'posts'>('posts', (attrs) => ({
+ *     title: 'Test Post',
+ *     content: 'Test content',
+ *     ...attrs
+ *   }))
+ * };
+ *
+ * // Create factory instance
+ * const factory = new KyselyFactory(builders, seeds, db);
+ *
+ * // Use in tests
+ * const user = await factory.insert('user', { name: 'John Doe' });
+ * ```
+ */
+declare class KyselyFactory<DB, Builders extends Record<string, any>, Seeds extends Record<string, any>> extends Factory<Builders, Seeds> {
+  private builders;
+  private seeds;
+  private db;
+  /**
+   * Creates a typed seed function with proper type inference.
+   * Inherits from the base Factory class implementation.
+   *
+   * @template Seed - The seed function type
+   * @param seedFn - The seed function to wrap
+   * @returns The same seed function with proper typing
+   */
+  static createSeed<Seed extends FactorySeed>(seedFn: Seed): Seed;
+  /**
+   * Creates a new KyselyFactory instance.
+   *
+   * @param builders - Record of builder functions for creating individual entities
+   * @param seeds - Record of seed functions for creating complex test scenarios
+   * @param db - Kysely database instance or controlled transaction
+   */
+  constructor(builders: Builders, seeds: Seeds, db: Kysely<DB> | ControlledTransaction<DB, []>);
+  /**
+   * Creates a typed builder function for a specific database table.
+   * This is a utility method that helps create builders with proper type inference for Kysely.
+   *
+   * @template DB - The database schema type
+   * @template TableName - The name of the table (must be a key of DB)
+   * @template Attrs - The attributes type for the builder (defaults to Partial<Insertable>)
+   * @template Factory - The factory instance type
+   * @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 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
+   * const userBuilder = KyselyFactory.createBuilder<DB, 'users'>('users',
+   *   (attrs, factory, db, faker) => ({
+   *     id: faker.string.uuid(),
+   *     name: faker.person.fullName(),
+   *     email: faker.internet.email(),
+   *     createdAt: new Date(),
+   *     ...attrs
+   *   })
+   * );
+   *
+   * // Create a builder that doesn't auto-insert (useful for nested inserts)
+   * const addressBuilder = KyselyFactory.createBuilder<DB, 'addresses'>('addresses',
+   *   (attrs) => ({
+   *     street: '123 Main St',
+   *     city: 'Anytown',
+   *     ...attrs
+   *   }),
+   *   false // Don't auto-insert
+   * );
+   * ```
+   */
+  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>;
+  /**
+   * Inserts a single record into the database using the specified builder.
+   * The builder function is responsible for generating the record data with defaults
+   * and the factory handles the actual database insertion.
+   *
+   * @template K - The builder name (must be a key of Builders)
+   * @param builderName - The name of the builder to use
+   * @param attrs - Optional attributes to override builder defaults
+   * @returns A promise resolving to the inserted record
+   * @throws Error if the specified builder doesn't exist
+   *
+   * @example
+   * ```typescript
+   * // Insert with defaults
+   * const user = await factory.insert('user');
+   *
+   * // Insert with overrides
+   * const adminUser = await factory.insert('user', {
+   *   email: 'admin@example.com',
+   *   role: 'admin'
+   * });
+   *
+   * // Use the inserted record
+   * const post = await factory.insert('post', {
+   *   userId: user.id,
+   *   title: 'My First Post'
+   * });
+   * ```
+   */
+  insert<K extends keyof Builders>(builderName: K, attrs?: Parameters<Builders[K]>[0]): Promise<Awaited<ReturnType<Builders[K]>>>;
+  /**
+   * Inserts multiple records into the database using the specified builder.
+   * Supports both static attributes and dynamic attribute generation via a function.
+   *
+   * @template K - The builder name (must be a key of Builders)
+   * @param count - The number of records to insert
+   * @param builderName - The name of the builder to use
+   * @param attrs - Static attributes or a function that generates attributes for each record
+   * @returns A promise resolving to an array of inserted records
+   * @throws Error if the specified builder doesn't exist
+   *
+   * @example
+   * ```typescript
+   * // Insert multiple with same attributes
+   * const users = await factory.insertMany(5, 'user', { role: 'member' });
+   *
+   * // Insert multiple with dynamic attributes
+   * const posts = await factory.insertMany(10, 'post', (idx, faker) => ({
+   *   title: `Post ${idx + 1}`,
+   *   content: faker.lorem.paragraph(),
+   *   publishedAt: faker.date.past()
+   * }));
+   *
+   * // Create users with sequential emails
+   * const admins = await factory.insertMany(3, 'user', (idx) => ({
+   *   email: `admin${idx + 1}@example.com`,
+   *   role: 'admin'
+   * }));
+   * ```
+   */
+  insertMany<K extends keyof Builders>(count: number, builderName: K, attrs?: Parameters<Builders[K]>[0]): Promise<Awaited<ReturnType<Builders[K]>>[]>;
+  insertMany<K extends keyof Builders>(count: number, builderName: K, attrs: (idx: number, faker: FakerFactory) => Parameters<Builders[K]>[0]): Promise<Awaited<ReturnType<Builders[K]>>[]>;
+  /**
+   * Executes a seed function to create complex test scenarios with multiple related records.
+   * Seeds are useful for setting up complete test environments with realistic data relationships.
+   *
+   * @template K - The seed name (must be a key of Seeds)
+   * @param seedName - The name of the seed to execute
+   * @param attrs - Optional configuration attributes for the seed
+   * @returns The result of the seed function (typically the primary record created)
+   * @throws Error if the specified seed doesn't exist
+   *
+   * @example
+   * ```typescript
+   * // Execute a simple seed
+   * const user = await factory.seed('userWithProfile');
+   *
+   * // Execute a seed with configuration
+   * const author = await factory.seed('authorWithBooks', {
+   *   bookCount: 5,
+   *   includeReviews: true
+   * });
+   *
+   * // Use seed result in tests
+   * const company = await factory.seed('companyWithDepartments', {
+   *   departmentCount: 3,
+   *   employeesPerDepartment: 10
+   * });
+   * expect(company.departments).toHaveLength(3);
+   * ```
+   */
+  seed<K extends keyof Seeds>(seedName: K, attrs?: Parameters<Seeds[K]>[0]): ReturnType<Seeds[K]>;
+}
+//#endregion
+export { KyselyFactory };

package/dist/KyselyFactory-CrLWxJW4.d.cts

@@ -0,0 +1,200 @@
+import { FakerFactory } from "./faker-DAiFK3T3.cjs";
+import { Factory, FactorySeed } from "./Factory-B9LP1L18.cjs";
+import { ControlledTransaction, Insertable, Kysely, Selectable } from "kysely";
+
+//#region src/KyselyFactory.d.ts
+
+/**
+ * Factory implementation for Kysely ORM, providing test data creation utilities.
+ * Extends the base Factory class with Kysely-specific database operations.
+ *
+ * @template DB - The database schema type
+ * @template Builders - Record of builder functions for creating entities
+ * @template Seeds - Record of seed functions for complex test scenarios
+ *
+ * @example
+ * ```typescript
+ * // Define your database schema
+ * interface Database {
+ *   users: UsersTable;
+ *   posts: PostsTable;
+ * }
+ *
+ * // Create builders
+ * const builders = {
+ *   user: KyselyFactory.createBuilder<Database, 'users'>('users', (attrs, factory, db, faker) => ({
+ *     id: faker.string.uuid(),
+ *     name: faker.person.fullName(),
+ *     email: faker.internet.email(),
+ *     ...attrs
+ *   })),
+ *   post: KyselyFactory.createBuilder<Database, 'posts'>('posts', (attrs) => ({
+ *     title: 'Test Post',
+ *     content: 'Test content',
+ *     ...attrs
+ *   }))
+ * };
+ *
+ * // Create factory instance
+ * const factory = new KyselyFactory(builders, seeds, db);
+ *
+ * // Use in tests
+ * const user = await factory.insert('user', { name: 'John Doe' });
+ * ```
+ */
+declare class KyselyFactory<DB, Builders extends Record<string, any>, Seeds extends Record<string, any>> extends Factory<Builders, Seeds> {
+  private builders;
+  private seeds;
+  private db;
+  /**
+   * Creates a typed seed function with proper type inference.
+   * Inherits from the base Factory class implementation.
+   *
+   * @template Seed - The seed function type
+   * @param seedFn - The seed function to wrap
+   * @returns The same seed function with proper typing
+   */
+  static createSeed<Seed extends FactorySeed>(seedFn: Seed): Seed;
+  /**
+   * Creates a new KyselyFactory instance.
+   *
+   * @param builders - Record of builder functions for creating individual entities
+   * @param seeds - Record of seed functions for creating complex test scenarios
+   * @param db - Kysely database instance or controlled transaction
+   */
+  constructor(builders: Builders, seeds: Seeds, db: Kysely<DB> | ControlledTransaction<DB, []>);
+  /**
+   * Creates a typed builder function for a specific database table.
+   * This is a utility method that helps create builders with proper type inference for Kysely.
+   *
+   * @template DB - The database schema type
+   * @template TableName - The name of the table (must be a key of DB)
+   * @template Attrs - The attributes type for the builder (defaults to Partial<Insertable>)
+   * @template Factory - The factory instance type
+   * @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 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
+   * const userBuilder = KyselyFactory.createBuilder<DB, 'users'>('users',
+   *   (attrs, factory, db, faker) => ({
+   *     id: faker.string.uuid(),
+   *     name: faker.person.fullName(),
+   *     email: faker.internet.email(),
+   *     createdAt: new Date(),
+   *     ...attrs
+   *   })
+   * );
+   *
+   * // Create a builder that doesn't auto-insert (useful for nested inserts)
+   * const addressBuilder = KyselyFactory.createBuilder<DB, 'addresses'>('addresses',
+   *   (attrs) => ({
+   *     street: '123 Main St',
+   *     city: 'Anytown',
+   *     ...attrs
+   *   }),
+   *   false // Don't auto-insert
+   * );
+   * ```
+   */
+  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>;
+  /**
+   * Inserts a single record into the database using the specified builder.
+   * The builder function is responsible for generating the record data with defaults
+   * and the factory handles the actual database insertion.
+   *
+   * @template K - The builder name (must be a key of Builders)
+   * @param builderName - The name of the builder to use
+   * @param attrs - Optional attributes to override builder defaults
+   * @returns A promise resolving to the inserted record
+   * @throws Error if the specified builder doesn't exist
+   *
+   * @example
+   * ```typescript
+   * // Insert with defaults
+   * const user = await factory.insert('user');
+   *
+   * // Insert with overrides
+   * const adminUser = await factory.insert('user', {
+   *   email: 'admin@example.com',
+   *   role: 'admin'
+   * });
+   *
+   * // Use the inserted record
+   * const post = await factory.insert('post', {
+   *   userId: user.id,
+   *   title: 'My First Post'
+   * });
+   * ```
+   */
+  insert<K extends keyof Builders>(builderName: K, attrs?: Parameters<Builders[K]>[0]): Promise<Awaited<ReturnType<Builders[K]>>>;
+  /**
+   * Inserts multiple records into the database using the specified builder.
+   * Supports both static attributes and dynamic attribute generation via a function.
+   *
+   * @template K - The builder name (must be a key of Builders)
+   * @param count - The number of records to insert
+   * @param builderName - The name of the builder to use
+   * @param attrs - Static attributes or a function that generates attributes for each record
+   * @returns A promise resolving to an array of inserted records
+   * @throws Error if the specified builder doesn't exist
+   *
+   * @example
+   * ```typescript
+   * // Insert multiple with same attributes
+   * const users = await factory.insertMany(5, 'user', { role: 'member' });
+   *
+   * // Insert multiple with dynamic attributes
+   * const posts = await factory.insertMany(10, 'post', (idx, faker) => ({
+   *   title: `Post ${idx + 1}`,
+   *   content: faker.lorem.paragraph(),
+   *   publishedAt: faker.date.past()
+   * }));
+   *
+   * // Create users with sequential emails
+   * const admins = await factory.insertMany(3, 'user', (idx) => ({
+   *   email: `admin${idx + 1}@example.com`,
+   *   role: 'admin'
+   * }));
+   * ```
+   */
+  insertMany<K extends keyof Builders>(count: number, builderName: K, attrs?: Parameters<Builders[K]>[0]): Promise<Awaited<ReturnType<Builders[K]>>[]>;
+  insertMany<K extends keyof Builders>(count: number, builderName: K, attrs: (idx: number, faker: FakerFactory) => Parameters<Builders[K]>[0]): Promise<Awaited<ReturnType<Builders[K]>>[]>;
+  /**
+   * Executes a seed function to create complex test scenarios with multiple related records.
+   * Seeds are useful for setting up complete test environments with realistic data relationships.
+   *
+   * @template K - The seed name (must be a key of Seeds)
+   * @param seedName - The name of the seed to execute
+   * @param attrs - Optional configuration attributes for the seed
+   * @returns The result of the seed function (typically the primary record created)
+   * @throws Error if the specified seed doesn't exist
+   *
+   * @example
+   * ```typescript
+   * // Execute a simple seed
+   * const user = await factory.seed('userWithProfile');
+   *
+   * // Execute a seed with configuration
+   * const author = await factory.seed('authorWithBooks', {
+   *   bookCount: 5,
+   *   includeReviews: true
+   * });
+   *
+   * // Use seed result in tests
+   * const company = await factory.seed('companyWithDepartments', {
+   *   departmentCount: 3,
+   *   employeesPerDepartment: 10
+   * });
+   * expect(company.departments).toHaveLength(3);
+   * ```
+   */
+  seed<K extends keyof Seeds>(seedName: K, attrs?: Parameters<Seeds[K]>[0]): ReturnType<Seeds[K]>;
+}
+//#endregion
+export { KyselyFactory };

package/dist/KyselyFactory.d.cts

@@ -0,0 +1,4 @@
+import "./faker-DAiFK3T3.cjs";
+import "./Factory-B9LP1L18.cjs";
+import { KyselyFactory } from "./KyselyFactory-CrLWxJW4.cjs";
+export { KyselyFactory };

package/dist/KyselyFactory.d.mts

@@ -0,0 +1,4 @@
+import "./faker-nN9Ki6fn.mjs";
+import "./Factory-DiZSNxC0.mjs";
+import { KyselyFactory } from "./KyselyFactory-B-zlLbov.mjs";
+export { KyselyFactory };