@geekmidas/testkit 10.0.0-alpha.2 → 10.0.0-alpha.20

package/dist/KyselyFactory-DRlMv-WT.d.mts

@@ -1,228 +0,0 @@
-import { FakerFactory } from "./faker-DsYCplsG.mjs";
-import { ExtractSeedAttrs, Factory, FactorySeed } from "./Factory-CVR3GdkW.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, 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 (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;
-  /**
-   * 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 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 - destructure only what you need
-   * const userBuilder = KyselyFactory.createBuilder<DB, 'users'>('users',
-   *   ({ attrs, faker }) => ({
-   *     id: faker.string.uuid(),
-   *     name: faker.person.fullName(),
-   *     email: faker.internet.email(),
-   *     createdAt: new Date(),
-   *     ...attrs
-   *   })
-   * );
-   *
-   * // 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 }) => ({
-   *     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, 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
-   * 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<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?: ExtractSeedAttrs<Seeds[K]>): ReturnType<Seeds[K]>;
-}
-//# sourceMappingURL=KyselyFactory.d.ts.map
-//#endregion
-export { KyselyFactory };
-//# sourceMappingURL=KyselyFactory-DRlMv-WT.d.mts.map

package/dist/KyselyFactory-DRlMv-WT.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"KyselyFactory-DRlMv-WT.d.mts","names":[],"sources":["../src/KyselyFactory.ts"],"sourcesContent":[],"mappings":";;;;;;;;AA+CA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4GK,cA5GQ,aA4GR,CAAA,EAAA,EAAA,iBA1Ga,MA0Gb,CAAA,MAAA,EAAA,GAAA,CAAA,EAAA,cAzGU,MAyGV,CAAA,MAAA,EAAA,GAAA,CAAA,CAAA,SAxGK,OAwGL,CAxGa,QAwGb,EAxGuB,KAwGvB,CAAA,CAAA;EAAO,QACoB,QAAA;EAAE,QAAC,KAAA;EAAS,QAAvB,EAAA;EAAU;;;;;;;;;;;;;;;;;;;;;EAwJf,OACK,UAAA,CAAA,aA5OoB,WA4OpB,CAAA,CAAA,MAAA,EA5OyC,IA4OzC,CAAA,EA5OgD,IA4OhD;EAAQ;;;;;;;EAClB,WACuB,CAAA,QAAA,EAlOd,QAkOc,EAAA,KAAA,EAjOjB,KAiOiB,EAAA,EAAA,EAhOpB,MAgOoB,CAhOb,EAgOa,CAAA,GAhOP,qBAgOO,CAhOe,EAgOf,EAAA,EAAA,CAAA;EAAQ;;;;;;;;;;;;;;;;;;;;;;;AApQzB;;;;;;;;;;;;;;;;;;;;;;;;mDA0FS,2BACV,QAAQ,WAAW,GAAG,eAAe,QAClD,WAAW,GAAG,sCAGN,WAAW,GAAG,oBAEhB;WAEC;aACE;QACL,OAAO;WACJ;QAEL,QAAQ,WAAW,GAAG,eACtB,QAAQ,QAAQ,WAAW,GAAG,8CAG1B,gBACE,aACL,OAAO,YACJ,iBACH,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yBAuEgB,uBACf,WACL,WAAW,SAAS,SAC1B,QAAQ,QAAQ,WAAW,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6BAqEN,sCAEnB,WACL,WAAW,SAAS,SAC1B,QAAQ,QAAQ,WAAW,SAAS;6BACN,sCAEnB,+BAGL,iBACH,WAAW,SAAS,SAAS,QAAQ,WAAW,SAAS,UAC5D,QAAQ,QAAQ,WAAW,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uBAsDlB,iBACV,WACF,iBAAiB,MAAM,MAC7B,WAAW,MAAM"}

package/dist/KyselyFactory-hMcVtvJq.d.cts

@@ -1,228 +0,0 @@
-import { FakerFactory } from "./faker-Dg3trU4a.cjs";
-import { ExtractSeedAttrs, Factory, FactorySeed } from "./Factory-Cwzho3c8.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, 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 (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;
-  /**
-   * 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 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 - destructure only what you need
-   * const userBuilder = KyselyFactory.createBuilder<DB, 'users'>('users',
-   *   ({ attrs, faker }) => ({
-   *     id: faker.string.uuid(),
-   *     name: faker.person.fullName(),
-   *     email: faker.internet.email(),
-   *     createdAt: new Date(),
-   *     ...attrs
-   *   })
-   * );
-   *
-   * // 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 }) => ({
-   *     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, 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
-   * 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<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?: ExtractSeedAttrs<Seeds[K]>): ReturnType<Seeds[K]>;
-}
-//# sourceMappingURL=KyselyFactory.d.ts.map
-//#endregion
-export { KyselyFactory };
-//# sourceMappingURL=KyselyFactory-hMcVtvJq.d.cts.map

package/dist/KyselyFactory-hMcVtvJq.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"KyselyFactory-hMcVtvJq.d.cts","names":[],"sources":["../src/KyselyFactory.ts"],"sourcesContent":[],"mappings":";;;;;;;;AA+CA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4GK,cA5GQ,aA4GR,CAAA,EAAA,EAAA,iBA1Ga,MA0Gb,CAAA,MAAA,EAAA,GAAA,CAAA,EAAA,cAzGU,MAyGV,CAAA,MAAA,EAAA,GAAA,CAAA,CAAA,SAxGK,OAwGL,CAxGa,QAwGb,EAxGuB,KAwGvB,CAAA,CAAA;EAAO,QACoB,QAAA;EAAE,QAAC,KAAA;EAAS,QAAvB,EAAA;EAAU;;;;;;;;;;;;;;;;;;;;;EAwJf,OACK,UAAA,CAAA,aA5OoB,WA4OpB,CAAA,CAAA,MAAA,EA5OyC,IA4OzC,CAAA,EA5OgD,IA4OhD;EAAQ;;;;;;;EAClB,WACuB,CAAA,QAAA,EAlOd,QAkOc,EAAA,KAAA,EAjOjB,KAiOiB,EAAA,EAAA,EAhOpB,MAgOoB,CAhOb,EAgOa,CAAA,GAhOP,qBAgOO,CAhOe,EAgOf,EAAA,EAAA,CAAA;EAAQ;;;;;;;;;;;;;;;;;;;;;;;AApQzB;;;;;;;;;;;;;;;;;;;;;;;;mDA0FS,2BACV,QAAQ,WAAW,GAAG,eAAe,QAClD,WAAW,GAAG,sCAGN,WAAW,GAAG,oBAEhB;WAEC;aACE;QACL,OAAO;WACJ;QAEL,QAAQ,WAAW,GAAG,eACtB,QAAQ,QAAQ,WAAW,GAAG,8CAG1B,gBACE,aACL,OAAO,YACJ,iBACH,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yBAuEgB,uBACf,WACL,WAAW,SAAS,SAC1B,QAAQ,QAAQ,WAAW,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6BAqEN,sCAEnB,WACL,WAAW,SAAS,SAC1B,QAAQ,QAAQ,WAAW,SAAS;6BACN,sCAEnB,+BAGL,iBACH,WAAW,SAAS,SAAS,QAAQ,WAAW,SAAS,UAC5D,QAAQ,QAAQ,WAAW,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uBAsDlB,iBACV,WACF,iBAAiB,MAAM,MAC7B,WAAW,MAAM"}