@geekmidas/testkit 0.0.15 → 0.0.17

package/dist/{Factory-D7P3bKKb.d.mts → Factory-BZ8uMoXl.d.cts}

@@ -1,4 +1,4 @@
-import { FakerFactory } from "./faker-C-Iuk_R1.mjs";
+import { FakerFactory } from "./faker-Cg76aFNO.cjs";
 
 //#region src/Factory.d.ts
 
@@ -128,4 +128,5 @@ 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>;
 //#endregion
-export { Factory, FactorySeed, MixedFactoryBuilder };
+export { Factory, FactorySeed, MixedFactoryBuilder };
+//# sourceMappingURL=Factory-BZ8uMoXl.d.cts.map

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

@@ -1,4 +1,4 @@
-import { FakerFactory } from "./faker-BSH1EMtg.cjs";
+import { FakerFactory } from "./faker-Br8MzXil.mjs";
 
 //#region src/Factory.d.ts
 
@@ -128,4 +128,5 @@ 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>;
 //#endregion
-export { Factory, FactorySeed, MixedFactoryBuilder };
+export { Factory, FactorySeed, MixedFactoryBuilder };
+//# sourceMappingURL=Factory-CRquB4vz.d.mts.map

package/dist/Factory-WMhTNZ9S.cjs

@@ -53,4 +53,5 @@ Object.defineProperty(exports, 'Factory', {
   get: function () {
     return Factory;
   }
-});
+});
+//# sourceMappingURL=Factory-WMhTNZ9S.cjs.map

package/dist/Factory-WMhTNZ9S.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Factory-WMhTNZ9S.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?: Parameters<Seeds[K]>[0],\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 attrs - Configuration attributes for the seed\n * @param factory - The factory instance for creating records\n * @param 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<Attrs = any, Factory = any, Result = any, DB = any> = (\n  attrs: Attrs,\n  factory: Factory,\n  db: DB,\n) => Promise<Result>;\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;AA2BA,IAAsB,UAAtB,MAGE;;;;;;;;;;;;;;;;;CAiBA,OAAO,WAAqCA,QAAoB;AAC9D,SAAO;CACR;AAyCF"}

package/dist/Factory-z2m01hMj.mjs

@@ -47,4 +47,5 @@ var Factory = class {
 };
 
 //#endregion
-export { Factory };
+export { Factory };
+//# sourceMappingURL=Factory-z2m01hMj.mjs.map

package/dist/Factory-z2m01hMj.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Factory-z2m01hMj.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?: Parameters<Seeds[K]>[0],\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 attrs - Configuration attributes for the seed\n * @param factory - The factory instance for creating records\n * @param 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<Attrs = any, Factory = any, Result = any, DB = any> = (\n  attrs: Attrs,\n  factory: Factory,\n  db: DB,\n) => Promise<Result>;\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;AA2BA,IAAsB,UAAtB,MAGE;;;;;;;;;;;;;;;;;CAiBA,OAAO,WAAqCA,QAAoB;AAC9D,SAAO;CACR;AAyCF"}

package/dist/Factory.d.cts

@@ -1,3 +1,3 @@
-import "./faker-BSH1EMtg.cjs";
-import { Factory, FactorySeed, MixedFactoryBuilder } from "./Factory-pNV7ZQ7-.cjs";
+import "./faker-Cg76aFNO.cjs";
+import { Factory, FactorySeed, MixedFactoryBuilder } from "./Factory-BZ8uMoXl.cjs";
 export { Factory, FactorySeed, MixedFactoryBuilder };

package/dist/Factory.d.mts

@@ -1,3 +1,3 @@
-import "./faker-C-Iuk_R1.mjs";
-import { Factory, FactorySeed, MixedFactoryBuilder } from "./Factory-D7P3bKKb.mjs";
+import "./faker-Br8MzXil.mjs";
+import { Factory, FactorySeed, MixedFactoryBuilder } from "./Factory-CRquB4vz.mjs";
 export { Factory, FactorySeed, MixedFactoryBuilder };

package/dist/{KyselyFactory-72P98y5I.d.mts → KyselyFactory-BDS_QqRT.d.mts}

@@ -1,5 +1,5 @@
-import { FakerFactory } from "./faker-C-Iuk_R1.mjs";
-import { Factory, FactorySeed } from "./Factory-D7P3bKKb.mjs";
+import { FakerFactory } from "./faker-Br8MzXil.mjs";
+import { Factory, FactorySeed } from "./Factory-CRquB4vz.mjs";
 import { ControlledTransaction, Insertable, Kysely, Selectable } from "kysely";
 
 //#region src/KyselyFactory.d.ts
@@ -197,4 +197,5 @@ declare class KyselyFactory<DB, Builders extends Record<string, any>, Seeds exte
   seed<K extends keyof Seeds>(seedName: K, attrs?: Parameters<Seeds[K]>[0]): ReturnType<Seeds[K]>;
 }
 //#endregion
-export { KyselyFactory };
+export { KyselyFactory };
+//# sourceMappingURL=KyselyFactory-BDS_QqRT.d.mts.map

package/dist/KyselyFactory-BcYkC0t2.mjs

@@ -207,4 +207,5 @@ var KyselyFactory = class extends Factory {
 };
 
 //#endregion
-export { KyselyFactory };
+export { KyselyFactory };
+//# sourceMappingURL=KyselyFactory-BcYkC0t2.mjs.map

package/dist/KyselyFactory-BcYkC0t2.mjs.map

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

package/dist/KyselyFactory-Cf0o2YxO.cjs

@@ -212,4 +212,5 @@ Object.defineProperty(exports, 'KyselyFactory', {
   get: function () {
     return KyselyFactory;
   }
-});
+});
+//# sourceMappingURL=KyselyFactory-Cf0o2YxO.cjs.map

package/dist/KyselyFactory-Cf0o2YxO.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"KyselyFactory-Cf0o2YxO.cjs","names":["Factory","seedFn: Seed","builders: Builders","seeds: Seeds","db: Kysely<DB> | ControlledTransaction<DB, []>","table: TableName","item?: (\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>","faker: FakerFactory","data: Partial<Insertable<DB[TableName]>>","faker","builderName: K","attrs?: Parameters<Builders[K]>[0]","count: number","attrs?: any","promises: Promise<any>[]","seedName: K","attrs?: Parameters<Seeds[K]>[0]"],"sources":["../src/KyselyFactory.ts"],"sourcesContent":["import type {\n  ControlledTransaction,\n  Insertable,\n  Kysely,\n  Selectable,\n} from 'kysely';\nimport { Factory, type FactorySeed } from './Factory.ts';\nimport { type FakerFactory, faker } from './faker.ts';\n\n/**\n * Factory implementation for Kysely ORM, providing test data creation utilities.\n * Extends the base Factory class with Kysely-specific database operations.\n *\n * @template DB - The database schema type\n * @template Builders - Record of builder functions for creating entities\n * @template Seeds - Record of seed functions for complex test scenarios\n *\n * @example\n * ```typescript\n * // Define your database schema\n * interface Database {\n *   users: UsersTable;\n *   posts: PostsTable;\n * }\n *\n * // Create builders\n * const builders = {\n *   user: KyselyFactory.createBuilder<Database, 'users'>('users', (attrs, factory, db, faker) => ({\n *     id: faker.string.uuid(),\n *     name: faker.person.fullName(),\n *     email: faker.internet.email(),\n *     ...attrs\n *   })),\n *   post: KyselyFactory.createBuilder<Database, 'posts'>('posts', (attrs) => ({\n *     title: 'Test Post',\n *     content: 'Test content',\n *     ...attrs\n *   }))\n * };\n *\n * // Create factory instance\n * const factory = new KyselyFactory(builders, seeds, db);\n *\n * // Use in tests\n * const user = await factory.insert('user', { name: 'John Doe' });\n * ```\n */\nexport class KyselyFactory<\n  DB,\n  Builders extends Record<string, any>,\n  Seeds extends Record<string, any>,\n> extends Factory<Builders, Seeds> {\n  /**\n   * Creates a typed seed function with proper type inference.\n   * Inherits from the base Factory class implementation.\n   *\n   * @template Seed - The seed function type\n   * @param seedFn - The seed function to wrap\n   * @returns The same seed function with proper typing\n   */\n  static createSeed<Seed extends FactorySeed>(seedFn: Seed): Seed {\n    return Factory.createSeed(seedFn);\n  }\n\n  /**\n   * Creates a new KyselyFactory instance.\n   *\n   * @param builders - Record of builder functions for creating individual entities\n   * @param seeds - Record of seed functions for creating complex test scenarios\n   * @param db - Kysely database instance or controlled transaction\n   */\n  constructor(\n    private builders: Builders,\n    private seeds: Seeds,\n    private db: Kysely<DB> | ControlledTransaction<DB, []>,\n  ) {\n    super();\n  }\n\n  /**\n   * Creates a typed builder function for a specific database table.\n   * This is a utility method that helps create builders with proper type inference for Kysely.\n   *\n   * @template DB - The database schema type\n   * @template TableName - The name of the table (must be a key of DB)\n   * @template Attrs - The attributes type for the builder (defaults to Partial<Insertable>)\n   * @template Factory - The factory instance type\n   * @template Result - The result type (defaults to Selectable of the table)\n   *\n   * @param table - The name of the database table\n   * @param item - Optional function to provide default values and transformations\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\n   * const userBuilder = KyselyFactory.createBuilder<DB, 'users'>('users',\n   *   (attrs, factory, db, 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   * // 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    item?: (\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      faker: FakerFactory,\n    ) => {\n      // Start with attributes\n      let data: Partial<Insertable<DB[TableName]>> = { ...attrs };\n\n      // Apply defaults\n      if (item) {\n        const defaults = await item(attrs, factory, db, faker);\n        data = { ...defaults, ...data };\n      }\n\n      // Handle insertion based on autoInsert flag\n      if (autoInsert !== false) {\n        // Auto insert is enabled by default\n        const result = await db\n          .insertInto(table)\n          .values(data as Insertable<DB[TableName]>)\n          .returningAll()\n          .executeTakeFirst();\n\n        if (!result) {\n          throw new Error(`Failed to insert into ${table}`);\n        }\n\n        return result as Result;\n      } else {\n        // Return object for factory to handle insertion\n        return { table, data } as any;\n      }\n    };\n  }\n\n  /**\n   * Inserts a single record into the database using the specified builder.\n   * The builder function is responsible for generating the record data with defaults\n   * and the factory handles the actual database insertion.\n   *\n   * @template K - The builder name (must be a key of Builders)\n   * @param builderName - The name of the builder to use\n   * @param attrs - Optional attributes to override builder defaults\n   * @returns A promise resolving to the inserted record\n   * @throws Error if the specified builder doesn't exist\n   *\n   * @example\n   * ```typescript\n   * // Insert with defaults\n   * const user = await factory.insert('user');\n   *\n   * // Insert with overrides\n   * const adminUser = await factory.insert('user', {\n   *   email: 'admin@example.com',\n   *   role: 'admin'\n   * });\n   *\n   * // Use the inserted record\n   * const post = await factory.insert('post', {\n   *   userId: user.id,\n   *   title: 'My First Post'\n   * });\n   * ```\n   */\n  async insert<K extends keyof Builders>(\n    builderName: K,\n    attrs?: Parameters<Builders[K]>[0],\n  ): Promise<Awaited<ReturnType<Builders[K]>>> {\n    if (!(builderName in this.builders)) {\n      throw new Error(\n        `Factory \"${\n          builderName as string\n        }\" does not exist. Make sure it is correct and registered in src/test/setup.ts`,\n      );\n    }\n\n    const result = await this.builders[builderName](\n      attrs || {},\n      this,\n      this.db,\n      faker,\n    );\n\n    // For Kysely, we expect the builder to return an object with table and data properties\n    // or to handle the insertion itself and return the inserted record\n    if (\n      result &&\n      typeof result === 'object' &&\n      'table' in result &&\n      'data' in result\n    ) {\n      // If the builder returns {table: string, data: object}, we insert it\n      const inserted = await this.db\n        .insertInto(result.table)\n        .values(result.data)\n        .returningAll()\n        .executeTakeFirst();\n\n      return inserted as any;\n    }\n\n    // Otherwise, assume the builder handled the insertion itself\n    return result;\n  }\n\n  /**\n   * Inserts multiple records into the database using the specified builder.\n   * Supports both static attributes and dynamic attribute generation via a function.\n   *\n   * @template K - The builder name (must be a key of Builders)\n   * @param count - The number of records to insert\n   * @param builderName - The name of the builder to use\n   * @param attrs - Static attributes or a function that generates attributes for each record\n   * @returns A promise resolving to an array of inserted records\n   * @throws Error if the specified builder doesn't exist\n   *\n   * @example\n   * ```typescript\n   * // Insert multiple with same attributes\n   * const users = await factory.insertMany(5, 'user', { role: 'member' });\n   *\n   * // Insert multiple with dynamic attributes\n   * const posts = await factory.insertMany(10, 'post', (idx, faker) => ({\n   *   title: `Post ${idx + 1}`,\n   *   content: faker.lorem.paragraph(),\n   *   publishedAt: faker.date.past()\n   * }));\n   *\n   * // Create users with sequential emails\n   * const admins = await factory.insertMany(3, 'user', (idx) => ({\n   *   email: `admin${idx + 1}@example.com`,\n   *   role: 'admin'\n   * }));\n   * ```\n   */\n  // Method overloads for better type inference\n  async insertMany<K extends keyof Builders>(\n    count: number,\n    builderName: K,\n    attrs?: Parameters<Builders[K]>[0],\n  ): Promise<Awaited<ReturnType<Builders[K]>>[]>;\n  async insertMany<K extends keyof Builders>(\n    count: number,\n    builderName: K,\n    attrs: (\n      idx: number,\n      faker: FakerFactory,\n    ) => Parameters<Builders[K]>[0] | Promise<Parameters<Builders[K]>[0]>,\n  ): Promise<Awaited<ReturnType<Builders[K]>>[]>;\n  async insertMany<K extends keyof Builders>(\n    count: number,\n    builderName: K,\n    attrs?: any,\n  ): Promise<Awaited<ReturnType<Builders[K]>>[]> {\n    if (!(builderName in this.builders)) {\n      throw new Error(\n        `Builder \"${\n          builderName as string\n        }\" is not registered in this factory. Make sure it is correct and registered in src/test/setup.ts`,\n      );\n    }\n\n    const promises: Promise<any>[] = [];\n\n    for (let i = 0; i < count; i++) {\n      const newAttrs =\n        typeof attrs === 'function' ? await attrs(i, faker) : attrs;\n      promises.push(this.insert(builderName, newAttrs));\n    }\n\n    return Promise.all(promises);\n  }\n\n  /**\n   * Executes a seed function to create complex test scenarios with multiple related records.\n   * Seeds are useful for setting up complete test environments with realistic data relationships.\n   *\n   * @template K - The seed name (must be a key of Seeds)\n   * @param seedName - The name of the seed to execute\n   * @param attrs - Optional configuration attributes for the seed\n   * @returns The result of the seed function (typically the primary record created)\n   * @throws Error if the specified seed doesn't exist\n   *\n   * @example\n   * ```typescript\n   * // Execute a simple seed\n   * const user = await factory.seed('userWithProfile');\n   *\n   * // Execute a seed with configuration\n   * const author = await factory.seed('authorWithBooks', {\n   *   bookCount: 5,\n   *   includeReviews: true\n   * });\n   *\n   * // Use seed result in tests\n   * const company = await factory.seed('companyWithDepartments', {\n   *   departmentCount: 3,\n   *   employeesPerDepartment: 10\n   * });\n   * expect(company.departments).toHaveLength(3);\n   * ```\n   */\n  seed<K extends keyof Seeds>(\n    seedName: K,\n    attrs?: Parameters<Seeds[K]>[0],\n  ): ReturnType<Seeds[K]> {\n    if (!(seedName in this.seeds)) {\n      throw new Error(\n        `Seed \"${\n          seedName as string\n        }\" is not registered in this factory. Make sure it is correct and registered in src/test/setup.ts`,\n      );\n    }\n\n    return this.seeds[seedName](attrs || {}, this, this.db);\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+CA,IAAa,gBAAb,cAIUA,wBAAyB;;;;;;;;;CASjC,OAAO,WAAqCC,QAAoB;AAC9D,SAAO,wBAAQ,WAAW,OAAO;CAClC;;;;;;;;CASD,YACUC,UACAC,OACAC,IACR;AACA,SAAO;EAJC;EACA;EACA;CAGT;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAyCD,OAAO,cASLC,OACAC,MAQAC,YAMmB;AACnB,SAAO,OACLC,OACAC,SACAC,IACAC,YACG;GAEH,IAAIC,OAA2C,EAAE,GAAG,MAAO;AAG3D,OAAI,MAAM;IACR,MAAM,WAAW,MAAM,KAAK,OAAO,SAAS,IAAIC,QAAM;AACtD,WAAO;KAAE,GAAG;KAAU,GAAG;IAAM;GAChC;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,IACLF,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,WACJG,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,GAAGL,oBAAM,GAAG;AACxD,YAAS,KAAK,KAAK,OAAO,aAAa,SAAS,CAAC;EAClD;AAED,SAAO,QAAQ,IAAI,SAAS;CAC7B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+BD,KACEM,UACAC,OACsB;AACtB,QAAM,YAAY,KAAK,OACrB,OAAM,IAAI,OACP,QACC,SACD;AAIL,SAAO,KAAK,MAAM,UAAU,SAAS,CAAE,GAAE,MAAM,KAAK,GAAG;CACxD;AACF"}

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

@@ -1,5 +1,5 @@
-import { FakerFactory } from "./faker-BSH1EMtg.cjs";
-import { Factory, FactorySeed } from "./Factory-pNV7ZQ7-.cjs";
+import { FakerFactory } from "./faker-Cg76aFNO.cjs";
+import { Factory, FactorySeed } from "./Factory-BZ8uMoXl.cjs";
 import { ControlledTransaction, Insertable, Kysely, Selectable } from "kysely";
 
 //#region src/KyselyFactory.d.ts
@@ -197,4 +197,5 @@ declare class KyselyFactory<DB, Builders extends Record<string, any>, Seeds exte
   seed<K extends keyof Seeds>(seedName: K, attrs?: Parameters<Seeds[K]>[0]): ReturnType<Seeds[K]>;
 }
 //#endregion
-export { KyselyFactory };
+export { KyselyFactory };
+//# sourceMappingURL=KyselyFactory-DRQ83r0o.d.cts.map

package/dist/KyselyFactory.d.cts

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

package/dist/KyselyFactory.d.mts

@@ -1,4 +1,4 @@
-import "./faker-C-Iuk_R1.mjs";
-import "./Factory-D7P3bKKb.mjs";
-import { KyselyFactory } from "./KyselyFactory-72P98y5I.mjs";
+import "./faker-Br8MzXil.mjs";
+import "./Factory-CRquB4vz.mjs";
+import { KyselyFactory } from "./KyselyFactory-BDS_QqRT.mjs";
 export { KyselyFactory };

package/dist/ObjectionFactory-8hebmnai.mjs

@@ -233,4 +233,5 @@ var ObjectionFactory = class extends Factory {
 };
 
 //#endregion
-export { ObjectionFactory };
+export { ObjectionFactory };
+//# sourceMappingURL=ObjectionFactory-8hebmnai.mjs.map

package/dist/ObjectionFactory-8hebmnai.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"ObjectionFactory-8hebmnai.mjs","names":["seedFn: Seed","ModelClass: TModel","item?: (\n      attrs: Attrs,\n      factory: Factory,\n      db: Knex,\n      faker: FakerFactory,\n    ) => Partial<InstanceType<TModel>> | Promise<Partial<InstanceType<TModel>>>","autoInsert?: boolean","attrs: Attrs","factory: Factory","db: Knex","faker: FakerFactory","data: Partial<InstanceType<TModel>>","faker","builders: Builders","seeds: Seeds","builderName: K","attrs?: Parameters<Builders[K]>[0]","count: number","attrs?: any","records: any[]","record: any","seedName: K","attrs?: Parameters<Seeds[K]>[0]"],"sources":["../src/ObjectionFactory.ts"],"sourcesContent":["import type { Knex } from 'knex';\nimport type { Model } from 'objection';\nimport { Factory, type FactorySeed } from './Factory.ts';\nimport { type FakerFactory, faker } from './faker.ts';\n\n/**\n * Factory implementation for Objection.js ORM, providing test data creation utilities.\n * Extends the base Factory class with Objection.js-specific database operations.\n *\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 models with Objection.js\n * class User extends Model {\n *   static tableName = 'users';\n * }\n *\n * // Create builders\n * const builders = {\n *   user: (attrs) => User.fromJson({\n *     id: faker.string.uuid(),\n *     name: faker.person.fullName(),\n *     email: faker.internet.email(),\n *     ...attrs\n *   }),\n *   post: (attrs) => Post.fromJson({\n *     title: 'Test Post',\n *     content: 'Test content',\n *     ...attrs\n *   })\n * };\n *\n * // Create factory instance\n * const factory = new ObjectionFactory(builders, seeds, knex);\n *\n * // Use in tests\n * const user = await factory.insert('user', { name: 'John Doe' });\n * ```\n */\nexport class ObjectionFactory<\n  Builders extends Record<string, any>,\n  Seeds extends Record<string, any>,\n> extends Factory<Builders, Seeds> {\n  /**\n   * Creates a typed seed function with proper type inference.\n   * Inherits from the base Factory class implementation.\n   *\n   * @template Seed - The seed function type\n   * @param seedFn - The seed function to wrap\n   * @returns The same seed function with proper typing\n   */\n  static createSeed<Seed extends FactorySeed>(seedFn: Seed): Seed {\n    return Factory.createSeed(seedFn);\n  }\n\n  /**\n   * Creates a typed builder function for Objection.js models.\n   * This is a utility method that helps create builders with proper type inference.\n   *\n   * @template TModel - The Objection.js Model class type\n   * @template Attrs - The attributes type for the builder (defaults to Partial of model)\n   * @template Factory - The factory instance type\n   * @template Result - The result type (defaults to the model instance)\n   *\n   * @param ModelClass - The Objection.js Model class\n   * @param item - Optional function to provide default values and transformations\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\n   * const userBuilder = ObjectionFactory.createBuilder(User,\n   *   (attrs, factory, db, 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   * // Create a builder that doesn't auto-insert (useful for nested inserts)\n   * const addressBuilder = ObjectionFactory.createBuilder(Address,\n   *   (attrs) => ({\n   *     street: '123 Main St',\n   *     city: 'Anytown',\n   *     ...attrs\n   *   }),\n   *   false // Don't auto-insert\n   * );\n   *\n   * // Use with relations\n   * const postBuilder = ObjectionFactory.createBuilder(Post,\n   *   async (attrs, factory) => ({\n   *     title: faker.lorem.sentence(),\n   *     content: faker.lorem.paragraphs(),\n   *     authorId: attrs.authorId || (await factory.insert('user')).id,\n   *     ...attrs\n   *   })\n   * );\n   * ```\n   */\n  static createBuilder<\n    TModel extends typeof Model,\n    Attrs extends Partial<InstanceType<TModel>> = Partial<InstanceType<TModel>>,\n    Factory = any,\n    Result = InstanceType<TModel>,\n  >(\n    ModelClass: TModel,\n    item?: (\n      attrs: Attrs,\n      factory: Factory,\n      db: Knex,\n      faker: FakerFactory,\n    ) => Partial<InstanceType<TModel>> | Promise<Partial<InstanceType<TModel>>>,\n    autoInsert?: boolean,\n  ): (\n    attrs: Attrs,\n    factory: Factory,\n    db: Knex,\n    faker: FakerFactory,\n  ) => Promise<Result> {\n    return async (\n      attrs: Attrs,\n      factory: Factory,\n      db: Knex,\n      faker: FakerFactory,\n    ) => {\n      // Start with attributes\n      let data: Partial<InstanceType<TModel>> = { ...attrs };\n\n      // Apply defaults\n      if (item) {\n        const defaults = await item(attrs, factory, db, faker);\n        data = { ...defaults, ...data };\n      }\n\n      // Create model instance\n      const model = ModelClass.fromJson(data) as InstanceType<TModel>;\n\n      // Handle insertion based on autoInsert flag\n      if (autoInsert !== false) {\n        // Auto insert is enabled by default\n        // Extract only defined values for insertion\n        const insertData = Object.entries(model).reduce((acc, [key, value]) => {\n          if (value !== undefined && key !== 'id') {\n            acc[key] = value;\n          }\n          return acc;\n        }, {} as any);\n\n        // Use static query method to insert data directly\n        // @ts-ignore\n        const result = await ModelClass.query(db).insert(insertData);\n        return result as Result;\n      } else {\n        // Return model for factory to handle insertion\n        return model as Result;\n      }\n    };\n  }\n\n  /**\n   * Creates a new ObjectionFactory 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 - Knex database connection instance\n   */\n  constructor(\n    private builders: Builders,\n    private seeds: Seeds,\n    private db: Knex,\n  ) {\n    super();\n  }\n\n  /**\n   * Inserts a single record into the database using the specified builder.\n   * Uses Objection.js's insertGraph method to handle nested relations.\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 with all relations\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   * // Insert with nested relations\n   * const userWithProfile = await factory.insert('user', {\n   *   name: 'John Doe',\n   *   profile: {\n   *     bio: 'Software Developer',\n   *     avatar: 'avatar.jpg'\n   *   }\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    // If the builder returns a model instance, insert it\n    if (result && typeof result.$query === 'function') {\n      // Extract data from model, excluding undefined values and id\n      const insertData = Object.entries(result).reduce((acc, [key, value]) => {\n        if (value !== undefined && key !== 'id') {\n          acc[key] = value;\n        }\n        return acc;\n      }, {} as any);\n\n      // Use the model's constructor to get the query builder\n      return await result.constructor.query(this.db).insert(insertData);\n    }\n\n    // Otherwise, assume the builder handled insertion itself\n    return result;\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   * @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) => ({\n   *   title: `Post ${idx + 1}`,\n   *   content: `Content for post ${idx + 1}`,\n   *   publishedAt: new Date()\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: (idx: number, faker: FakerFactory) => 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 records: any[] = [];\n    for (let i = 0; i < count; i++) {\n      const newAttrs =\n        typeof attrs === 'function' ? await (attrs as any)(i, faker) : attrs;\n\n      records.push(\n        this.builders[builderName](newAttrs, this, this.db, faker).then(\n          (record: any) => {\n            // If the builder returns a model instance, insert it\n            if (record && typeof record.$query === 'function') {\n              // Extract data from model, excluding undefined values and id\n              const insertData = Object.entries(record).reduce(\n                (acc, [key, value]) => {\n                  if (value !== undefined && key !== 'id') {\n                    acc[key] = value;\n                  }\n                  return acc;\n                },\n                {} as any,\n              );\n\n              // Use the model's constructor to get the query builder\n              return record.constructor.query(this.db).insert(insertData);\n            }\n            // Otherwise, assume the builder handled insertion itself\n            return record;\n          },\n        ),\n      );\n    }\n\n    return Promise.all(records);\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 with Objection.js relations\n   * const company = await factory.seed('companyWithDepartments', {\n   *   departmentCount: 3,\n   *   employeesPerDepartment: 10\n   * });\n   *\n   * // Access eager loaded relations\n   * const companyWithRelations = await Company.query()\n   *   .findById(company.id)\n   *   .withGraphFetched('[departments.employees]');\n   * ```\n   */\n  seed<K extends keyof Seeds>(\n    seedName: K,\n    attrs?: Parameters<Seeds[K]>[0],\n  ): ReturnType<Seeds[K]> {\n    if (!(seedName in this.seeds)) {\n      throw new Error(\n        `Seed \"${\n          seedName as string\n        }\" is not registered in this factory. Make sure it is correct and registered in src/test/setup.ts`,\n      );\n    }\n\n    return this.seeds[seedName](attrs || {}, this, this.db);\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAyCA,IAAa,mBAAb,cAGU,QAAyB;;;;;;;;;CASjC,OAAO,WAAqCA,QAAoB;AAC9D,SAAO,QAAQ,WAAW,OAAO;CAClC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkDD,OAAO,cAMLC,YACAC,MAMAC,YAMmB;AACnB,SAAO,OACLC,OACAC,SACAC,IACAC,YACG;GAEH,IAAIC,OAAsC,EAAE,GAAG,MAAO;AAGtD,OAAI,MAAM;IACR,MAAM,WAAW,MAAM,KAAK,OAAO,SAAS,IAAIC,QAAM;AACtD,WAAO;KAAE,GAAG;KAAU,GAAG;IAAM;GAChC;GAGD,MAAM,QAAQ,WAAW,SAAS,KAAK;AAGvC,OAAI,eAAe,OAAO;IAGxB,MAAM,aAAa,OAAO,QAAQ,MAAM,CAAC,OAAO,CAAC,KAAK,CAAC,KAAK,MAAM,KAAK;AACrE,SAAI,oBAAuB,QAAQ,KACjC,KAAI,OAAO;AAEb,YAAO;IACR,GAAE,CAAE,EAAQ;IAIb,MAAM,SAAS,MAAM,WAAW,MAAM,GAAG,CAAC,OAAO,WAAW;AAC5D,WAAO;GACR,MAEC,QAAO;EAEV;CACF;;;;;;;;CASD,YACUC,UACAC,OACAL,IACR;AACA,SAAO;EAJC;EACA;EACA;CAGT;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAiCD,MAAM,OACJM,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;AAGD,MAAI,iBAAiB,OAAO,WAAW,YAAY;GAEjD,MAAM,aAAa,OAAO,QAAQ,OAAO,CAAC,OAAO,CAAC,KAAK,CAAC,KAAK,MAAM,KAAK;AACtE,QAAI,oBAAuB,QAAQ,KACjC,KAAI,OAAO;AAEb,WAAO;GACR,GAAE,CAAE,EAAQ;AAGb,UAAO,MAAM,OAAO,YAAY,MAAM,KAAK,GAAG,CAAC,OAAO,WAAW;EAClE;AAGD,SAAO;CACR;CAyCD,MAAM,WACJC,OACAF,aACAG,OAC6C;AAC7C,QAAM,eAAe,KAAK,UACxB,OAAM,IAAI,OACP,WACC,YACD;EAIL,MAAMC,UAAiB,CAAE;AACzB,OAAK,IAAI,IAAI,GAAG,IAAI,OAAO,KAAK;GAC9B,MAAM,kBACG,UAAU,aAAa,MAAM,AAAC,MAAc,GAAG,MAAM,GAAG;AAEjE,WAAQ,KACN,KAAK,SAAS,aAAa,UAAU,MAAM,KAAK,IAAI,MAAM,CAAC,KACzD,CAACC,WAAgB;AAEf,QAAI,iBAAiB,OAAO,WAAW,YAAY;KAEjD,MAAM,aAAa,OAAO,QAAQ,OAAO,CAAC,OACxC,CAAC,KAAK,CAAC,KAAK,MAAM,KAAK;AACrB,UAAI,oBAAuB,QAAQ,KACjC,KAAI,OAAO;AAEb,aAAO;KACR,GACD,CAAE,EACH;AAGD,YAAO,OAAO,YAAY,MAAM,KAAK,GAAG,CAAC,OAAO,WAAW;IAC5D;AAED,WAAO;GACR,EACF,CACF;EACF;AAED,SAAO,QAAQ,IAAI,QAAQ;CAC5B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkCD,KACEC,UACAC,OACsB;AACtB,QAAM,YAAY,KAAK,OACrB,OAAM,IAAI,OACP,QACC,SACD;AAIL,SAAO,KAAK,MAAM,UAAU,SAAS,CAAE,GAAE,MAAM,KAAK,GAAG;CACxD;AACF"}

package/dist/{ObjectionFactory-B40NQWSe.d.mts → ObjectionFactory-C3tHvX1d.d.mts}

@@ -1,5 +1,5 @@
-import { FakerFactory } from "./faker-C-Iuk_R1.mjs";
-import { Factory, FactorySeed } from "./Factory-D7P3bKKb.mjs";
+import { FakerFactory } from "./faker-Br8MzXil.mjs";
+import { Factory, FactorySeed } from "./Factory-CRquB4vz.mjs";
 import { Knex } from "knex";
 import { Model } from "objection";
 
@@ -210,4 +210,5 @@ declare class ObjectionFactory<Builders extends Record<string, any>, Seeds exten
   seed<K extends keyof Seeds>(seedName: K, attrs?: Parameters<Seeds[K]>[0]): ReturnType<Seeds[K]>;
 }
 //#endregion
-export { ObjectionFactory };
+export { ObjectionFactory };
+//# sourceMappingURL=ObjectionFactory-C3tHvX1d.d.mts.map

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

@@ -1,5 +1,5 @@
-import { FakerFactory } from "./faker-BSH1EMtg.cjs";
-import { Factory, FactorySeed } from "./Factory-pNV7ZQ7-.cjs";
+import { FakerFactory } from "./faker-Cg76aFNO.cjs";
+import { Factory, FactorySeed } from "./Factory-BZ8uMoXl.cjs";
 import { Knex } from "knex";
 import { Model } from "objection";
 
@@ -210,4 +210,5 @@ declare class ObjectionFactory<Builders extends Record<string, any>, Seeds exten
   seed<K extends keyof Seeds>(seedName: K, attrs?: Parameters<Seeds[K]>[0]): ReturnType<Seeds[K]>;
 }
 //#endregion
-export { ObjectionFactory };
+export { ObjectionFactory };
+//# sourceMappingURL=ObjectionFactory-C4X78k0B.d.cts.map

package/dist/ObjectionFactory-CDriunkS.cjs

@@ -238,4 +238,5 @@ Object.defineProperty(exports, 'ObjectionFactory', {
   get: function () {
     return ObjectionFactory;
   }
-});
+});
+//# sourceMappingURL=ObjectionFactory-CDriunkS.cjs.map

package/dist/ObjectionFactory-CDriunkS.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"ObjectionFactory-CDriunkS.cjs","names":["Factory","seedFn: Seed","ModelClass: TModel","item?: (\n      attrs: Attrs,\n      factory: Factory,\n      db: Knex,\n      faker: FakerFactory,\n    ) => Partial<InstanceType<TModel>> | Promise<Partial<InstanceType<TModel>>>","autoInsert?: boolean","attrs: Attrs","factory: Factory","db: Knex","faker: FakerFactory","data: Partial<InstanceType<TModel>>","faker","builders: Builders","seeds: Seeds","builderName: K","attrs?: Parameters<Builders[K]>[0]","count: number","attrs?: any","records: any[]","record: any","seedName: K","attrs?: Parameters<Seeds[K]>[0]"],"sources":["../src/ObjectionFactory.ts"],"sourcesContent":["import type { Knex } from 'knex';\nimport type { Model } from 'objection';\nimport { Factory, type FactorySeed } from './Factory.ts';\nimport { type FakerFactory, faker } from './faker.ts';\n\n/**\n * Factory implementation for Objection.js ORM, providing test data creation utilities.\n * Extends the base Factory class with Objection.js-specific database operations.\n *\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 models with Objection.js\n * class User extends Model {\n *   static tableName = 'users';\n * }\n *\n * // Create builders\n * const builders = {\n *   user: (attrs) => User.fromJson({\n *     id: faker.string.uuid(),\n *     name: faker.person.fullName(),\n *     email: faker.internet.email(),\n *     ...attrs\n *   }),\n *   post: (attrs) => Post.fromJson({\n *     title: 'Test Post',\n *     content: 'Test content',\n *     ...attrs\n *   })\n * };\n *\n * // Create factory instance\n * const factory = new ObjectionFactory(builders, seeds, knex);\n *\n * // Use in tests\n * const user = await factory.insert('user', { name: 'John Doe' });\n * ```\n */\nexport class ObjectionFactory<\n  Builders extends Record<string, any>,\n  Seeds extends Record<string, any>,\n> extends Factory<Builders, Seeds> {\n  /**\n   * Creates a typed seed function with proper type inference.\n   * Inherits from the base Factory class implementation.\n   *\n   * @template Seed - The seed function type\n   * @param seedFn - The seed function to wrap\n   * @returns The same seed function with proper typing\n   */\n  static createSeed<Seed extends FactorySeed>(seedFn: Seed): Seed {\n    return Factory.createSeed(seedFn);\n  }\n\n  /**\n   * Creates a typed builder function for Objection.js models.\n   * This is a utility method that helps create builders with proper type inference.\n   *\n   * @template TModel - The Objection.js Model class type\n   * @template Attrs - The attributes type for the builder (defaults to Partial of model)\n   * @template Factory - The factory instance type\n   * @template Result - The result type (defaults to the model instance)\n   *\n   * @param ModelClass - The Objection.js Model class\n   * @param item - Optional function to provide default values and transformations\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\n   * const userBuilder = ObjectionFactory.createBuilder(User,\n   *   (attrs, factory, db, 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   * // Create a builder that doesn't auto-insert (useful for nested inserts)\n   * const addressBuilder = ObjectionFactory.createBuilder(Address,\n   *   (attrs) => ({\n   *     street: '123 Main St',\n   *     city: 'Anytown',\n   *     ...attrs\n   *   }),\n   *   false // Don't auto-insert\n   * );\n   *\n   * // Use with relations\n   * const postBuilder = ObjectionFactory.createBuilder(Post,\n   *   async (attrs, factory) => ({\n   *     title: faker.lorem.sentence(),\n   *     content: faker.lorem.paragraphs(),\n   *     authorId: attrs.authorId || (await factory.insert('user')).id,\n   *     ...attrs\n   *   })\n   * );\n   * ```\n   */\n  static createBuilder<\n    TModel extends typeof Model,\n    Attrs extends Partial<InstanceType<TModel>> = Partial<InstanceType<TModel>>,\n    Factory = any,\n    Result = InstanceType<TModel>,\n  >(\n    ModelClass: TModel,\n    item?: (\n      attrs: Attrs,\n      factory: Factory,\n      db: Knex,\n      faker: FakerFactory,\n    ) => Partial<InstanceType<TModel>> | Promise<Partial<InstanceType<TModel>>>,\n    autoInsert?: boolean,\n  ): (\n    attrs: Attrs,\n    factory: Factory,\n    db: Knex,\n    faker: FakerFactory,\n  ) => Promise<Result> {\n    return async (\n      attrs: Attrs,\n      factory: Factory,\n      db: Knex,\n      faker: FakerFactory,\n    ) => {\n      // Start with attributes\n      let data: Partial<InstanceType<TModel>> = { ...attrs };\n\n      // Apply defaults\n      if (item) {\n        const defaults = await item(attrs, factory, db, faker);\n        data = { ...defaults, ...data };\n      }\n\n      // Create model instance\n      const model = ModelClass.fromJson(data) as InstanceType<TModel>;\n\n      // Handle insertion based on autoInsert flag\n      if (autoInsert !== false) {\n        // Auto insert is enabled by default\n        // Extract only defined values for insertion\n        const insertData = Object.entries(model).reduce((acc, [key, value]) => {\n          if (value !== undefined && key !== 'id') {\n            acc[key] = value;\n          }\n          return acc;\n        }, {} as any);\n\n        // Use static query method to insert data directly\n        // @ts-ignore\n        const result = await ModelClass.query(db).insert(insertData);\n        return result as Result;\n      } else {\n        // Return model for factory to handle insertion\n        return model as Result;\n      }\n    };\n  }\n\n  /**\n   * Creates a new ObjectionFactory 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 - Knex database connection instance\n   */\n  constructor(\n    private builders: Builders,\n    private seeds: Seeds,\n    private db: Knex,\n  ) {\n    super();\n  }\n\n  /**\n   * Inserts a single record into the database using the specified builder.\n   * Uses Objection.js's insertGraph method to handle nested relations.\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 with all relations\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   * // Insert with nested relations\n   * const userWithProfile = await factory.insert('user', {\n   *   name: 'John Doe',\n   *   profile: {\n   *     bio: 'Software Developer',\n   *     avatar: 'avatar.jpg'\n   *   }\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    // If the builder returns a model instance, insert it\n    if (result && typeof result.$query === 'function') {\n      // Extract data from model, excluding undefined values and id\n      const insertData = Object.entries(result).reduce((acc, [key, value]) => {\n        if (value !== undefined && key !== 'id') {\n          acc[key] = value;\n        }\n        return acc;\n      }, {} as any);\n\n      // Use the model's constructor to get the query builder\n      return await result.constructor.query(this.db).insert(insertData);\n    }\n\n    // Otherwise, assume the builder handled insertion itself\n    return result;\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   * @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) => ({\n   *   title: `Post ${idx + 1}`,\n   *   content: `Content for post ${idx + 1}`,\n   *   publishedAt: new Date()\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: (idx: number, faker: FakerFactory) => 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 records: any[] = [];\n    for (let i = 0; i < count; i++) {\n      const newAttrs =\n        typeof attrs === 'function' ? await (attrs as any)(i, faker) : attrs;\n\n      records.push(\n        this.builders[builderName](newAttrs, this, this.db, faker).then(\n          (record: any) => {\n            // If the builder returns a model instance, insert it\n            if (record && typeof record.$query === 'function') {\n              // Extract data from model, excluding undefined values and id\n              const insertData = Object.entries(record).reduce(\n                (acc, [key, value]) => {\n                  if (value !== undefined && key !== 'id') {\n                    acc[key] = value;\n                  }\n                  return acc;\n                },\n                {} as any,\n              );\n\n              // Use the model's constructor to get the query builder\n              return record.constructor.query(this.db).insert(insertData);\n            }\n            // Otherwise, assume the builder handled insertion itself\n            return record;\n          },\n        ),\n      );\n    }\n\n    return Promise.all(records);\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 with Objection.js relations\n   * const company = await factory.seed('companyWithDepartments', {\n   *   departmentCount: 3,\n   *   employeesPerDepartment: 10\n   * });\n   *\n   * // Access eager loaded relations\n   * const companyWithRelations = await Company.query()\n   *   .findById(company.id)\n   *   .withGraphFetched('[departments.employees]');\n   * ```\n   */\n  seed<K extends keyof Seeds>(\n    seedName: K,\n    attrs?: Parameters<Seeds[K]>[0],\n  ): ReturnType<Seeds[K]> {\n    if (!(seedName in this.seeds)) {\n      throw new Error(\n        `Seed \"${\n          seedName as string\n        }\" is not registered in this factory. Make sure it is correct and registered in src/test/setup.ts`,\n      );\n    }\n\n    return this.seeds[seedName](attrs || {}, this, this.db);\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAyCA,IAAa,mBAAb,cAGUA,wBAAyB;;;;;;;;;CASjC,OAAO,WAAqCC,QAAoB;AAC9D,SAAO,wBAAQ,WAAW,OAAO;CAClC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkDD,OAAO,cAMLC,YACAC,MAMAC,YAMmB;AACnB,SAAO,OACLC,OACAC,SACAC,IACAC,YACG;GAEH,IAAIC,OAAsC,EAAE,GAAG,MAAO;AAGtD,OAAI,MAAM;IACR,MAAM,WAAW,MAAM,KAAK,OAAO,SAAS,IAAIC,QAAM;AACtD,WAAO;KAAE,GAAG;KAAU,GAAG;IAAM;GAChC;GAGD,MAAM,QAAQ,WAAW,SAAS,KAAK;AAGvC,OAAI,eAAe,OAAO;IAGxB,MAAM,aAAa,OAAO,QAAQ,MAAM,CAAC,OAAO,CAAC,KAAK,CAAC,KAAK,MAAM,KAAK;AACrE,SAAI,oBAAuB,QAAQ,KACjC,KAAI,OAAO;AAEb,YAAO;IACR,GAAE,CAAE,EAAQ;IAIb,MAAM,SAAS,MAAM,WAAW,MAAM,GAAG,CAAC,OAAO,WAAW;AAC5D,WAAO;GACR,MAEC,QAAO;EAEV;CACF;;;;;;;;CASD,YACUC,UACAC,OACAL,IACR;AACA,SAAO;EAJC;EACA;EACA;CAGT;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAiCD,MAAM,OACJM,aACAC,OAC2C;AAC3C,QAAM,eAAe,KAAK,UACxB,OAAM,IAAI,OACP,WACC,YACD;EAIL,MAAM,SAAS,MAAM,KAAK,SAAS,aACjC,SAAS,CAAE,GACX,MACA,KAAK,IACLJ,oBACD;AAGD,MAAI,iBAAiB,OAAO,WAAW,YAAY;GAEjD,MAAM,aAAa,OAAO,QAAQ,OAAO,CAAC,OAAO,CAAC,KAAK,CAAC,KAAK,MAAM,KAAK;AACtE,QAAI,oBAAuB,QAAQ,KACjC,KAAI,OAAO;AAEb,WAAO;GACR,GAAE,CAAE,EAAQ;AAGb,UAAO,MAAM,OAAO,YAAY,MAAM,KAAK,GAAG,CAAC,OAAO,WAAW;EAClE;AAGD,SAAO;CACR;CAyCD,MAAM,WACJK,OACAF,aACAG,OAC6C;AAC7C,QAAM,eAAe,KAAK,UACxB,OAAM,IAAI,OACP,WACC,YACD;EAIL,MAAMC,UAAiB,CAAE;AACzB,OAAK,IAAI,IAAI,GAAG,IAAI,OAAO,KAAK;GAC9B,MAAM,kBACG,UAAU,aAAa,MAAM,AAAC,MAAc,GAAGP,oBAAM,GAAG;AAEjE,WAAQ,KACN,KAAK,SAAS,aAAa,UAAU,MAAM,KAAK,IAAIA,oBAAM,CAAC,KACzD,CAACQ,WAAgB;AAEf,QAAI,iBAAiB,OAAO,WAAW,YAAY;KAEjD,MAAM,aAAa,OAAO,QAAQ,OAAO,CAAC,OACxC,CAAC,KAAK,CAAC,KAAK,MAAM,KAAK;AACrB,UAAI,oBAAuB,QAAQ,KACjC,KAAI,OAAO;AAEb,aAAO;KACR,GACD,CAAE,EACH;AAGD,YAAO,OAAO,YAAY,MAAM,KAAK,GAAG,CAAC,OAAO,WAAW;IAC5D;AAED,WAAO;GACR,EACF,CACF;EACF;AAED,SAAO,QAAQ,IAAI,QAAQ;CAC5B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkCD,KACEC,UACAC,OACsB;AACtB,QAAM,YAAY,KAAK,OACrB,OAAM,IAAI,OACP,QACC,SACD;AAIL,SAAO,KAAK,MAAM,UAAU,SAAS,CAAE,GAAE,MAAM,KAAK,GAAG;CACxD;AACF"}

package/dist/ObjectionFactory.d.cts

@@ -1,4 +1,4 @@
-import "./faker-BSH1EMtg.cjs";
-import "./Factory-pNV7ZQ7-.cjs";
-import { ObjectionFactory } from "./ObjectionFactory-D3l1VuyX.cjs";
+import "./faker-Cg76aFNO.cjs";
+import "./Factory-BZ8uMoXl.cjs";
+import { ObjectionFactory } from "./ObjectionFactory-C4X78k0B.cjs";
 export { ObjectionFactory };

package/dist/ObjectionFactory.d.mts

@@ -1,4 +1,4 @@
-import "./faker-C-Iuk_R1.mjs";
-import "./Factory-D7P3bKKb.mjs";
-import { ObjectionFactory } from "./ObjectionFactory-B40NQWSe.mjs";
+import "./faker-Br8MzXil.mjs";
+import "./Factory-CRquB4vz.mjs";
+import { ObjectionFactory } from "./ObjectionFactory-C3tHvX1d.mjs";
 export { ObjectionFactory };

package/dist/{PostgresKyselyMigrator-_6yHZigp.d.mts → PostgresKyselyMigrator-CIx3AFSR.d.mts}

@@ -1,4 +1,4 @@
-import { PostgresMigrator } from "./PostgresMigrator-BlvuQl7d.mjs";
+import { PostgresMigrator } from "./PostgresMigrator-DQaRxoaY.mjs";
 import { Kysely, MigrationProvider } from "kysely";
 
 //#region src/PostgresKyselyMigrator.d.ts
@@ -64,4 +64,5 @@ declare class PostgresKyselyMigrator extends PostgresMigrator {
   migrate(): Promise<void>;
 }
 //#endregion
-export { PostgresKyselyMigrator };
+export { PostgresKyselyMigrator };
+//# sourceMappingURL=PostgresKyselyMigrator-CIx3AFSR.d.mts.map

package/dist/PostgresKyselyMigrator-CQ3aUoy_.d.cts

@@ -64,4 +64,5 @@ declare class PostgresKyselyMigrator extends PostgresMigrator {
   migrate(): Promise<void>;
 }
 //#endregion
-export { PostgresKyselyMigrator };
+export { PostgresKyselyMigrator };
+//# sourceMappingURL=PostgresKyselyMigrator-CQ3aUoy_.d.cts.map

package/dist/PostgresKyselyMigrator-CfytARcA.cjs

@@ -84,4 +84,5 @@ Object.defineProperty(exports, 'PostgresKyselyMigrator', {
   get: function () {
     return PostgresKyselyMigrator;
   }
-});
+});
+//# sourceMappingURL=PostgresKyselyMigrator-CfytARcA.cjs.map

package/dist/PostgresKyselyMigrator-CfytARcA.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"PostgresKyselyMigrator-CfytARcA.cjs","names":["PostgresMigrator","options: {\n      uri: string;\n      db: Kysely<any>;\n      provider: MigrationProvider;\n    }","Migrator"],"sources":["../src/PostgresKyselyMigrator.ts"],"sourcesContent":["import { type Kysely, type MigrationProvider, Migrator } from 'kysely';\nimport { PostgresMigrator } from './PostgresMigrator';\n\n/**\n * Default logger instance for migration operations.\n */\nconst logger = console;\n\n/**\n * PostgreSQL migrator implementation for Kysely ORM.\n * Extends PostgresMigrator to provide Kysely-specific migration functionality.\n * Automatically creates test databases and applies migrations for testing environments.\n *\n * @example\n * ```typescript\n * import { FileMigrationProvider } from 'kysely';\n * import { PostgresKyselyMigrator } from '@geekmidas/testkit';\n *\n * // Create migration provider\n * const provider = new FileMigrationProvider({\n *   fs: require('fs'),\n *   path: require('path'),\n *   migrationFolder: path.join(__dirname, 'migrations')\n * });\n *\n * // Create Kysely instance\n * const db = new Kysely<Database>({\n *   dialect: new PostgresDialect({\n *     pool: new Pool({ connectionString: uri })\n *   })\n * });\n *\n * // Create and use migrator\n * const migrator = new PostgresKyselyMigrator({\n *   uri: 'postgresql://localhost:5432/test_db',\n *   db,\n *   provider\n * });\n *\n * const cleanup = await migrator.start();\n * // Run tests...\n * await cleanup();\n * ```\n */\nexport class PostgresKyselyMigrator extends PostgresMigrator {\n  /**\n   * Creates a new PostgresKyselyMigrator instance.\n   *\n   * @param options - Configuration options\n   * @param options.uri - PostgreSQL connection URI\n   * @param options.db - Kysely database instance\n   * @param options.provider - Migration provider for locating migration files\n   */\n  constructor(\n    private options: {\n      uri: string;\n      db: Kysely<any>;\n      provider: MigrationProvider;\n    },\n  ) {\n    super(options.uri);\n  }\n\n  /**\n   * Executes Kysely migrations to the latest version.\n   * Implements the abstract migrate() method from PostgresMigrator.\n   *\n   * @throws Error if migrations fail to apply\n   * @returns Promise that resolves when all migrations are applied\n   */\n  async migrate(): Promise<void> {\n    const migrator = new Migrator({\n      db: this.options.db,\n      provider: this.options.provider,\n    });\n    const migrations = await migrator.migrateToLatest();\n\n    if (migrations.error) {\n      logger.error(migrations.error, `Failed to apply migrations`);\n      throw migrations.error;\n    }\n\n    await this.options.db.destroy();\n\n    logger.log(`Applied ${migrations.results?.length} migrations successfully`);\n  }\n}\n"],"mappings":";;;;;;;;AAMA,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAsCf,IAAa,yBAAb,cAA4CA,0CAAiB;;;;;;;;;CAS3D,YACUC,SAKR;AACA,QAAM,QAAQ,IAAI;EANV;CAOT;;;;;;;;CASD,MAAM,UAAyB;EAC7B,MAAM,WAAW,IAAIC,gBAAS;GAC5B,IAAI,KAAK,QAAQ;GACjB,UAAU,KAAK,QAAQ;EACxB;EACD,MAAM,aAAa,MAAM,SAAS,iBAAiB;AAEnD,MAAI,WAAW,OAAO;AACpB,UAAO,MAAM,WAAW,QAAQ,4BAA4B;AAC5D,SAAM,WAAW;EAClB;AAED,QAAM,KAAK,QAAQ,GAAG,SAAS;AAE/B,SAAO,KAAK,UAAU,WAAW,SAAS,OAAO,0BAA0B;CAC5E;AACF"}

package/dist/{PostgresKyselyMigrator-Bdhl251C.mjs → PostgresKyselyMigrator-upT-hmrz.mjs}

@@ -1,4 +1,4 @@
-import { PostgresMigrator } from "./PostgresMigrator-DxPC_gGu.mjs";
+import { PostgresMigrator } from "./PostgresMigrator-DbuJGAVy.mjs";
 import { Migrator } from "kysely";
 
 //#region src/PostgresKyselyMigrator.ts
@@ -78,4 +78,5 @@ var PostgresKyselyMigrator = class extends PostgresMigrator {
 };
 
 //#endregion
-export { PostgresKyselyMigrator };
+export { PostgresKyselyMigrator };
+//# sourceMappingURL=PostgresKyselyMigrator-upT-hmrz.mjs.map

package/dist/PostgresKyselyMigrator-upT-hmrz.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"PostgresKyselyMigrator-upT-hmrz.mjs","names":["options: {\n      uri: string;\n      db: Kysely<any>;\n      provider: MigrationProvider;\n    }"],"sources":["../src/PostgresKyselyMigrator.ts"],"sourcesContent":["import { type Kysely, type MigrationProvider, Migrator } from 'kysely';\nimport { PostgresMigrator } from './PostgresMigrator';\n\n/**\n * Default logger instance for migration operations.\n */\nconst logger = console;\n\n/**\n * PostgreSQL migrator implementation for Kysely ORM.\n * Extends PostgresMigrator to provide Kysely-specific migration functionality.\n * Automatically creates test databases and applies migrations for testing environments.\n *\n * @example\n * ```typescript\n * import { FileMigrationProvider } from 'kysely';\n * import { PostgresKyselyMigrator } from '@geekmidas/testkit';\n *\n * // Create migration provider\n * const provider = new FileMigrationProvider({\n *   fs: require('fs'),\n *   path: require('path'),\n *   migrationFolder: path.join(__dirname, 'migrations')\n * });\n *\n * // Create Kysely instance\n * const db = new Kysely<Database>({\n *   dialect: new PostgresDialect({\n *     pool: new Pool({ connectionString: uri })\n *   })\n * });\n *\n * // Create and use migrator\n * const migrator = new PostgresKyselyMigrator({\n *   uri: 'postgresql://localhost:5432/test_db',\n *   db,\n *   provider\n * });\n *\n * const cleanup = await migrator.start();\n * // Run tests...\n * await cleanup();\n * ```\n */\nexport class PostgresKyselyMigrator extends PostgresMigrator {\n  /**\n   * Creates a new PostgresKyselyMigrator instance.\n   *\n   * @param options - Configuration options\n   * @param options.uri - PostgreSQL connection URI\n   * @param options.db - Kysely database instance\n   * @param options.provider - Migration provider for locating migration files\n   */\n  constructor(\n    private options: {\n      uri: string;\n      db: Kysely<any>;\n      provider: MigrationProvider;\n    },\n  ) {\n    super(options.uri);\n  }\n\n  /**\n   * Executes Kysely migrations to the latest version.\n   * Implements the abstract migrate() method from PostgresMigrator.\n   *\n   * @throws Error if migrations fail to apply\n   * @returns Promise that resolves when all migrations are applied\n   */\n  async migrate(): Promise<void> {\n    const migrator = new Migrator({\n      db: this.options.db,\n      provider: this.options.provider,\n    });\n    const migrations = await migrator.migrateToLatest();\n\n    if (migrations.error) {\n      logger.error(migrations.error, `Failed to apply migrations`);\n      throw migrations.error;\n    }\n\n    await this.options.db.destroy();\n\n    logger.log(`Applied ${migrations.results?.length} migrations successfully`);\n  }\n}\n"],"mappings":";;;;;;;AAMA,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAsCf,IAAa,yBAAb,cAA4C,iBAAiB;;;;;;;;;CAS3D,YACUA,SAKR;AACA,QAAM,QAAQ,IAAI;EANV;CAOT;;;;;;;;CASD,MAAM,UAAyB;EAC7B,MAAM,WAAW,IAAI,SAAS;GAC5B,IAAI,KAAK,QAAQ;GACjB,UAAU,KAAK,QAAQ;EACxB;EACD,MAAM,aAAa,MAAM,SAAS,iBAAiB;AAEnD,MAAI,WAAW,OAAO;AACpB,UAAO,MAAM,WAAW,QAAQ,4BAA4B;AAC5D,SAAM,WAAW;EAClB;AAED,QAAM,KAAK,QAAQ,GAAG,SAAS;AAE/B,SAAO,KAAK,UAAU,WAAW,SAAS,OAAO,0BAA0B;CAC5E;AACF"}

package/dist/PostgresKyselyMigrator.d.mts

@@ -1,3 +1,3 @@
-import "./PostgresMigrator-BlvuQl7d.mjs";
-import { PostgresKyselyMigrator } from "./PostgresKyselyMigrator-_6yHZigp.mjs";
+import "./PostgresMigrator-DQaRxoaY.mjs";
+import { PostgresKyselyMigrator } from "./PostgresKyselyMigrator-CIx3AFSR.mjs";
 export { PostgresKyselyMigrator };

package/dist/PostgresKyselyMigrator.mjs

@@ -1,4 +1,4 @@
-import "./PostgresMigrator-DxPC_gGu.mjs";
-import { PostgresKyselyMigrator } from "./PostgresKyselyMigrator-Bdhl251C.mjs";
+import "./PostgresMigrator-DbuJGAVy.mjs";
+import { PostgresKyselyMigrator } from "./PostgresKyselyMigrator-upT-hmrz.mjs";
 
 export { PostgresKyselyMigrator };

package/dist/PostgresMigrator-D5UkK1_K.d.cts

@@ -81,4 +81,5 @@ declare abstract class PostgresMigrator {
   start(): Promise<() => Promise<void>>;
 }
 //#endregion
-export { PostgresMigrator };
+export { PostgresMigrator };
+//# sourceMappingURL=PostgresMigrator-D5UkK1_K.d.cts.map

package/dist/PostgresMigrator-DFcNdCvD.cjs

@@ -149,4 +149,5 @@ Object.defineProperty(exports, 'PostgresMigrator', {
   get: function () {
     return PostgresMigrator;
   }
-});
+});
+//# sourceMappingURL=PostgresMigrator-DFcNdCvD.cjs.map

package/dist/PostgresMigrator-DFcNdCvD.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"PostgresMigrator-DFcNdCvD.cjs","names":["uri: string"],"sources":["../src/PostgresMigrator.ts"],"sourcesContent":["import pg from 'pg';\n\nconst { Client } = pg;\n\n/**\n * Creates a PostgreSQL client connected to the 'postgres' database.\n * Extracts connection details from the provided URI.\n *\n * @param uri - PostgreSQL connection URI\n * @returns Object containing the target database name and client instance\n *\n * @example\n * ```typescript\n * const { database, db } = await setupClient('postgresql://user:pass@localhost:5432/mydb');\n * // database = 'mydb'\n * // db = Client instance connected to 'postgres' database\n * ```\n */\nasync function setupClient(uri: string) {\n  const url = new URL(uri);\n\n  const db = new Client({\n    user: url.username,\n    password: url.password,\n    host: url.hostname,\n    port: parseInt(url.port),\n    database: 'postgres',\n  });\n\n  let database = url.pathname.slice(1);\n  if (database.includes('?')) {\n    database = database.substring(0, database.indexOf('?'));\n  }\n  return { database, db };\n}\n\n/**\n * Default logger instance for migration operations.\n */\nconst logger = console;\n\n/**\n * Abstract base class for PostgreSQL database migration utilities.\n * Provides database creation, migration, and cleanup functionality for testing.\n * Subclasses must implement the migrate() method to define migration logic.\n *\n * @example\n * ```typescript\n * class MyMigrator extends PostgresMigrator {\n *   async migrate(): Promise<void> {\n *     // Run your migrations here\n *     await this.runMigrations();\n *   }\n * }\n *\n * // Use in tests\n * const migrator = new MyMigrator('postgresql://localhost:5432/test_db');\n * const cleanup = await migrator.start();\n *\n * // Run tests...\n *\n * // Clean up\n * await cleanup();\n * ```\n */\nexport abstract class PostgresMigrator {\n  /**\n   * Creates a new PostgresMigrator instance.\n   *\n   * @param uri - PostgreSQL connection URI\n   */\n  constructor(private uri: string) {}\n\n  /**\n   * Abstract method to be implemented by subclasses.\n   * Should contain the migration logic for setting up database schema.\n   *\n   * @returns Promise that resolves when migrations are complete\n   */\n  abstract migrate(): Promise<void>;\n\n  /**\n   * Creates a PostgreSQL database if it doesn't already exist.\n   * Connects to the 'postgres' database to check and create the target database.\n   *\n   * @param uri - PostgreSQL connection URI\n   * @returns Object indicating whether the database already existed\n   * @private\n   */\n  private static async create(\n    uri: string,\n  ): Promise<{ alreadyExisted: boolean }> {\n    const { database, db } = await setupClient(uri);\n    try {\n      await db.connect();\n      const result = await db.query(\n        `SELECT * FROM pg_catalog.pg_database WHERE datname = '${database}'`,\n      );\n\n      if (result.rowCount === 0) {\n        await db.query(`CREATE DATABASE \"${database}\"`);\n      }\n\n      return {\n        alreadyExisted: result.rowCount ? result.rowCount > 0 : false,\n      };\n    } finally {\n      await db.end();\n    }\n  }\n\n  /**\n   * Drops a PostgreSQL database.\n   * Used for cleanup after tests are complete.\n   *\n   * @param uri - PostgreSQL connection URI\n   * @throws Error if database cannot be dropped\n   * @private\n   */\n  private static async drop(uri: string): Promise<void> {\n    const { database, db } = await setupClient(uri);\n    try {\n      await db.connect();\n      await db.query(`DROP DATABASE \"${database}\"`);\n    } finally {\n      await db.end();\n    }\n  }\n\n  /**\n   * Starts the migration process by creating the database and running migrations.\n   * Returns a cleanup function that will drop the database when called.\n   *\n   * @returns Async cleanup function that drops the created database\n   *\n   * @example\n   * ```typescript\n   * const migrator = new MyMigrator('postgresql://localhost:5432/test_db');\n   *\n   * // Start migrations and get cleanup function\n   * const cleanup = await migrator.start();\n   *\n   * try {\n   *   // Run your tests here\n   *   await runTests();\n   * } finally {\n   *   // Always clean up\n   *   await cleanup();\n   * }\n   * ```\n   */\n  async start() {\n    const { database, db } = await setupClient(this.uri);\n    try {\n      await PostgresMigrator.create(this.uri);\n      // Implement migration logic here\n      await this.migrate();\n      logger.log(`Migrating database: ${database}`);\n      // Example: await db.query('CREATE TABLE example (id SERIAL PRIMARY KEY)');\n    } finally {\n      await db.end();\n    }\n\n    return async () => {\n      await PostgresMigrator.drop(this.uri);\n    };\n  }\n}\n"],"mappings":";;;;AAEA,MAAM,EAAE,QAAQ,GAAG;;;;;;;;;;;;;;;AAgBnB,eAAe,YAAYA,KAAa;CACtC,MAAM,MAAM,IAAI,IAAI;CAEpB,MAAM,KAAK,IAAI,OAAO;EACpB,MAAM,IAAI;EACV,UAAU,IAAI;EACd,MAAM,IAAI;EACV,MAAM,SAAS,IAAI,KAAK;EACxB,UAAU;CACX;CAED,IAAI,WAAW,IAAI,SAAS,MAAM,EAAE;AACpC,KAAI,SAAS,SAAS,IAAI,CACxB,YAAW,SAAS,UAAU,GAAG,SAAS,QAAQ,IAAI,CAAC;AAEzD,QAAO;EAAE;EAAU;CAAI;AACxB;;;;AAKD,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;AA0Bf,IAAsB,mBAAtB,MAAsB,iBAAiB;;;;;;CAMrC,YAAoBA,KAAa;EAAb;CAAe;;;;;;;;;CAkBnC,aAAqB,OACnBA,KACsC;EACtC,MAAM,EAAE,UAAU,IAAI,GAAG,MAAM,YAAY,IAAI;AAC/C,MAAI;AACF,SAAM,GAAG,SAAS;GAClB,MAAM,SAAS,MAAM,GAAG,OACrB,wDAAwD,SAAS,GACnE;AAED,OAAI,OAAO,aAAa,EACtB,OAAM,GAAG,OAAO,mBAAmB,SAAS,GAAG;AAGjD,UAAO,EACL,gBAAgB,OAAO,WAAW,OAAO,WAAW,IAAI,MACzD;EACF,UAAS;AACR,SAAM,GAAG,KAAK;EACf;CACF;;;;;;;;;CAUD,aAAqB,KAAKA,KAA4B;EACpD,MAAM,EAAE,UAAU,IAAI,GAAG,MAAM,YAAY,IAAI;AAC/C,MAAI;AACF,SAAM,GAAG,SAAS;AAClB,SAAM,GAAG,OAAO,iBAAiB,SAAS,GAAG;EAC9C,UAAS;AACR,SAAM,GAAG,KAAK;EACf;CACF;;;;;;;;;;;;;;;;;;;;;;;CAwBD,MAAM,QAAQ;EACZ,MAAM,EAAE,UAAU,IAAI,GAAG,MAAM,YAAY,KAAK,IAAI;AACpD,MAAI;AACF,SAAM,iBAAiB,OAAO,KAAK,IAAI;AAEvC,SAAM,KAAK,SAAS;AACpB,UAAO,KAAK,sBAAsB,SAAS,EAAE;EAE9C,UAAS;AACR,SAAM,GAAG,KAAK;EACf;AAED,SAAO,YAAY;AACjB,SAAM,iBAAiB,KAAK,KAAK,IAAI;EACtC;CACF;AACF"}

package/dist/{PostgresMigrator-BlvuQl7d.d.mts → PostgresMigrator-DQaRxoaY.d.mts}

@@ -81,4 +81,5 @@ declare abstract class PostgresMigrator {
   start(): Promise<() => Promise<void>>;
 }
 //#endregion
-export { PostgresMigrator };
+export { PostgresMigrator };
+//# sourceMappingURL=PostgresMigrator-DQaRxoaY.d.mts.map

package/dist/{PostgresMigrator-DxPC_gGu.mjs → PostgresMigrator-DbuJGAVy.mjs}

@@ -1,7 +1,7 @@
 import pg from "pg";
 
 //#region src/PostgresMigrator.ts
-const { Client: Client$1 } = pg;
+const { Client } = pg;
 /**
 * Creates a PostgreSQL client connected to the 'postgres' database.
 * Extracts connection details from the provided URI.
@@ -18,7 +18,7 @@ const { Client: Client$1 } = pg;
 */
 async function setupClient(uri) {
 	const url = new URL(uri);
-	const db = new Client$1({
+	const db = new Client({
 		user: url.username,
 		password: url.password,
 		host: url.hostname,
@@ -143,4 +143,5 @@ var PostgresMigrator = class PostgresMigrator {
 };
 
 //#endregion
-export { PostgresMigrator };
+export { PostgresMigrator };
+//# sourceMappingURL=PostgresMigrator-DbuJGAVy.mjs.map

package/dist/PostgresMigrator-DbuJGAVy.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"PostgresMigrator-DbuJGAVy.mjs","names":["uri: string"],"sources":["../src/PostgresMigrator.ts"],"sourcesContent":["import pg from 'pg';\n\nconst { Client } = pg;\n\n/**\n * Creates a PostgreSQL client connected to the 'postgres' database.\n * Extracts connection details from the provided URI.\n *\n * @param uri - PostgreSQL connection URI\n * @returns Object containing the target database name and client instance\n *\n * @example\n * ```typescript\n * const { database, db } = await setupClient('postgresql://user:pass@localhost:5432/mydb');\n * // database = 'mydb'\n * // db = Client instance connected to 'postgres' database\n * ```\n */\nasync function setupClient(uri: string) {\n  const url = new URL(uri);\n\n  const db = new Client({\n    user: url.username,\n    password: url.password,\n    host: url.hostname,\n    port: parseInt(url.port),\n    database: 'postgres',\n  });\n\n  let database = url.pathname.slice(1);\n  if (database.includes('?')) {\n    database = database.substring(0, database.indexOf('?'));\n  }\n  return { database, db };\n}\n\n/**\n * Default logger instance for migration operations.\n */\nconst logger = console;\n\n/**\n * Abstract base class for PostgreSQL database migration utilities.\n * Provides database creation, migration, and cleanup functionality for testing.\n * Subclasses must implement the migrate() method to define migration logic.\n *\n * @example\n * ```typescript\n * class MyMigrator extends PostgresMigrator {\n *   async migrate(): Promise<void> {\n *     // Run your migrations here\n *     await this.runMigrations();\n *   }\n * }\n *\n * // Use in tests\n * const migrator = new MyMigrator('postgresql://localhost:5432/test_db');\n * const cleanup = await migrator.start();\n *\n * // Run tests...\n *\n * // Clean up\n * await cleanup();\n * ```\n */\nexport abstract class PostgresMigrator {\n  /**\n   * Creates a new PostgresMigrator instance.\n   *\n   * @param uri - PostgreSQL connection URI\n   */\n  constructor(private uri: string) {}\n\n  /**\n   * Abstract method to be implemented by subclasses.\n   * Should contain the migration logic for setting up database schema.\n   *\n   * @returns Promise that resolves when migrations are complete\n   */\n  abstract migrate(): Promise<void>;\n\n  /**\n   * Creates a PostgreSQL database if it doesn't already exist.\n   * Connects to the 'postgres' database to check and create the target database.\n   *\n   * @param uri - PostgreSQL connection URI\n   * @returns Object indicating whether the database already existed\n   * @private\n   */\n  private static async create(\n    uri: string,\n  ): Promise<{ alreadyExisted: boolean }> {\n    const { database, db } = await setupClient(uri);\n    try {\n      await db.connect();\n      const result = await db.query(\n        `SELECT * FROM pg_catalog.pg_database WHERE datname = '${database}'`,\n      );\n\n      if (result.rowCount === 0) {\n        await db.query(`CREATE DATABASE \"${database}\"`);\n      }\n\n      return {\n        alreadyExisted: result.rowCount ? result.rowCount > 0 : false,\n      };\n    } finally {\n      await db.end();\n    }\n  }\n\n  /**\n   * Drops a PostgreSQL database.\n   * Used for cleanup after tests are complete.\n   *\n   * @param uri - PostgreSQL connection URI\n   * @throws Error if database cannot be dropped\n   * @private\n   */\n  private static async drop(uri: string): Promise<void> {\n    const { database, db } = await setupClient(uri);\n    try {\n      await db.connect();\n      await db.query(`DROP DATABASE \"${database}\"`);\n    } finally {\n      await db.end();\n    }\n  }\n\n  /**\n   * Starts the migration process by creating the database and running migrations.\n   * Returns a cleanup function that will drop the database when called.\n   *\n   * @returns Async cleanup function that drops the created database\n   *\n   * @example\n   * ```typescript\n   * const migrator = new MyMigrator('postgresql://localhost:5432/test_db');\n   *\n   * // Start migrations and get cleanup function\n   * const cleanup = await migrator.start();\n   *\n   * try {\n   *   // Run your tests here\n   *   await runTests();\n   * } finally {\n   *   // Always clean up\n   *   await cleanup();\n   * }\n   * ```\n   */\n  async start() {\n    const { database, db } = await setupClient(this.uri);\n    try {\n      await PostgresMigrator.create(this.uri);\n      // Implement migration logic here\n      await this.migrate();\n      logger.log(`Migrating database: ${database}`);\n      // Example: await db.query('CREATE TABLE example (id SERIAL PRIMARY KEY)');\n    } finally {\n      await db.end();\n    }\n\n    return async () => {\n      await PostgresMigrator.drop(this.uri);\n    };\n  }\n}\n"],"mappings":";;;AAEA,MAAM,EAAE,QAAQ,GAAG;;;;;;;;;;;;;;;AAgBnB,eAAe,YAAYA,KAAa;CACtC,MAAM,MAAM,IAAI,IAAI;CAEpB,MAAM,KAAK,IAAI,OAAO;EACpB,MAAM,IAAI;EACV,UAAU,IAAI;EACd,MAAM,IAAI;EACV,MAAM,SAAS,IAAI,KAAK;EACxB,UAAU;CACX;CAED,IAAI,WAAW,IAAI,SAAS,MAAM,EAAE;AACpC,KAAI,SAAS,SAAS,IAAI,CACxB,YAAW,SAAS,UAAU,GAAG,SAAS,QAAQ,IAAI,CAAC;AAEzD,QAAO;EAAE;EAAU;CAAI;AACxB;;;;AAKD,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;AA0Bf,IAAsB,mBAAtB,MAAsB,iBAAiB;;;;;;CAMrC,YAAoBA,KAAa;EAAb;CAAe;;;;;;;;;CAkBnC,aAAqB,OACnBA,KACsC;EACtC,MAAM,EAAE,UAAU,IAAI,GAAG,MAAM,YAAY,IAAI;AAC/C,MAAI;AACF,SAAM,GAAG,SAAS;GAClB,MAAM,SAAS,MAAM,GAAG,OACrB,wDAAwD,SAAS,GACnE;AAED,OAAI,OAAO,aAAa,EACtB,OAAM,GAAG,OAAO,mBAAmB,SAAS,GAAG;AAGjD,UAAO,EACL,gBAAgB,OAAO,WAAW,OAAO,WAAW,IAAI,MACzD;EACF,UAAS;AACR,SAAM,GAAG,KAAK;EACf;CACF;;;;;;;;;CAUD,aAAqB,KAAKA,KAA4B;EACpD,MAAM,EAAE,UAAU,IAAI,GAAG,MAAM,YAAY,IAAI;AAC/C,MAAI;AACF,SAAM,GAAG,SAAS;AAClB,SAAM,GAAG,OAAO,iBAAiB,SAAS,GAAG;EAC9C,UAAS;AACR,SAAM,GAAG,KAAK;EACf;CACF;;;;;;;;;;;;;;;;;;;;;;;CAwBD,MAAM,QAAQ;EACZ,MAAM,EAAE,UAAU,IAAI,GAAG,MAAM,YAAY,KAAK,IAAI;AACpD,MAAI;AACF,SAAM,iBAAiB,OAAO,KAAK,IAAI;AAEvC,SAAM,KAAK,SAAS;AACpB,UAAO,KAAK,sBAAsB,SAAS,EAAE;EAE9C,UAAS;AACR,SAAM,GAAG,KAAK;EACf;AAED,SAAO,YAAY;AACjB,SAAM,iBAAiB,KAAK,KAAK,IAAI;EACtC;CACF;AACF"}

package/dist/PostgresMigrator.d.mts

@@ -1,2 +1,2 @@
-import { PostgresMigrator } from "./PostgresMigrator-BlvuQl7d.mjs";
+import { PostgresMigrator } from "./PostgresMigrator-DQaRxoaY.mjs";
 export { PostgresMigrator };

package/dist/PostgresMigrator.mjs

@@ -1,3 +1,3 @@
-import { PostgresMigrator } from "./PostgresMigrator-DxPC_gGu.mjs";
+import { PostgresMigrator } from "./PostgresMigrator-DbuJGAVy.mjs";
 
 export { PostgresMigrator };

package/dist/PostgresObjectionMigrator-BG6ymgnt.cjs

@@ -119,4 +119,5 @@ Object.defineProperty(exports, 'PostgresObjectionMigrator', {
   get: function () {
     return PostgresObjectionMigrator;
   }
-});
+});
+//# sourceMappingURL=PostgresObjectionMigrator-BG6ymgnt.cjs.map

package/dist/PostgresObjectionMigrator-BG6ymgnt.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"PostgresObjectionMigrator-BG6ymgnt.cjs","names":["PostgresMigrator","options: {\n      uri: string;\n      knex: Knex;\n    }","migration: string"],"sources":["../src/PostgresObjectionMigrator.ts"],"sourcesContent":["import type { Knex } from 'knex';\nimport { PostgresMigrator } from './PostgresMigrator';\n\n/**\n * Default logger instance for migration operations.\n */\nconst logger = console;\n\n/**\n * PostgreSQL migrator implementation for Objection.js ORM with Knex.\n * Extends PostgresMigrator to provide Knex-specific migration functionality.\n * Automatically creates test databases and applies migrations for testing environments.\n *\n * @example\n * ```typescript\n * import knex from 'knex';\n * import { PostgresObjectionMigrator } from '@geekmidas/testkit';\n *\n * // Create Knex instance\n * const db = knex({\n *   client: 'pg',\n *   connection: uri,\n *   migrations: {\n *     directory: path.join(__dirname, 'migrations'),\n *     extension: 'ts'\n *   }\n * });\n *\n * // Create and use migrator\n * const migrator = new PostgresObjectionMigrator({\n *   uri: 'postgresql://localhost:5432/test_db',\n *   knex: db\n * });\n *\n * const cleanup = await migrator.start();\n * // Run tests...\n * await cleanup();\n * ```\n */\nexport class PostgresObjectionMigrator extends PostgresMigrator {\n  /**\n   * Creates a new PostgresObjectionMigrator instance.\n   *\n   * @param options - Configuration options\n   * @param options.uri - PostgreSQL connection URI\n   * @param options.knex - Knex database instance configured with migrations\n   */\n  constructor(\n    private options: {\n      uri: string;\n      knex: Knex;\n    },\n  ) {\n    super(options.uri);\n  }\n\n  /**\n   * Executes Knex migrations to the latest version.\n   * Implements the abstract migrate() method from PostgresMigrator.\n   *\n   * @throws Error if migrations fail to apply\n   * @returns Promise that resolves when all migrations are applied\n   */\n  async migrate(): Promise<void> {\n    try {\n      // Run migrations to latest\n      const [batchNo, migrations] = await this.options.knex.migrate.latest();\n\n      if (migrations.length > 0) {\n        logger.log(\n          `Applied batch ${batchNo} with ${migrations.length} migrations:`,\n        );\n        migrations.forEach((migration: string) => {\n          logger.log(`  - ${migration}`);\n        });\n      } else {\n        logger.log('No pending migrations to apply');\n      }\n    } catch (error) {\n      logger.error('Failed to apply migrations:', error);\n      throw error;\n    } finally {\n      // Always destroy the connection pool\n      await this.options.knex.destroy();\n    }\n  }\n\n  /**\n   * Rolls back the last batch of migrations.\n   * Useful for testing migration rollback scenarios.\n   *\n   * @returns Promise that resolves when rollback is complete\n   */\n  async rollback(): Promise<void> {\n    try {\n      const [batchNo, migrations] = await this.options.knex.migrate.rollback();\n\n      if (migrations.length > 0) {\n        logger.log(\n          `Rolled back batch ${batchNo} with ${migrations.length} migrations:`,\n        );\n        migrations.forEach((migration: string) => {\n          logger.log(`  - ${migration}`);\n        });\n      } else {\n        logger.log('No migrations to rollback');\n      }\n    } catch (error) {\n      logger.error('Failed to rollback migrations:', error);\n      throw error;\n    } finally {\n      await this.options.knex.destroy();\n    }\n  }\n\n  /**\n   * Gets the current migration status.\n   * Returns information about completed and pending migrations.\n   *\n   * @returns Promise with migration status information\n   */\n  async status(): Promise<{\n    completed: string[];\n    pending: string[];\n  }> {\n    try {\n      const completed = await this.options.knex.migrate.list();\n      const [, pending] = await this.options.knex.migrate.currentVersion();\n\n      return {\n        completed: Array.isArray(completed[0]) ? completed[0] : [],\n        pending: Array.isArray(pending) ? pending : [],\n      };\n    } finally {\n      await this.options.knex.destroy();\n    }\n  }\n}\n"],"mappings":";;;;;;AAMA,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAiCf,IAAa,4BAAb,cAA+CA,0CAAiB;;;;;;;;CAQ9D,YACUC,SAIR;AACA,QAAM,QAAQ,IAAI;EALV;CAMT;;;;;;;;CASD,MAAM,UAAyB;AAC7B,MAAI;GAEF,MAAM,CAAC,SAAS,WAAW,GAAG,MAAM,KAAK,QAAQ,KAAK,QAAQ,QAAQ;AAEtE,OAAI,WAAW,SAAS,GAAG;AACzB,WAAO,KACJ,gBAAgB,QAAQ,QAAQ,WAAW,OAAO,cACpD;AACD,eAAW,QAAQ,CAACC,cAAsB;AACxC,YAAO,KAAK,MAAM,UAAU,EAAE;IAC/B,EAAC;GACH,MACC,QAAO,IAAI,iCAAiC;EAE/C,SAAQ,OAAO;AACd,UAAO,MAAM,+BAA+B,MAAM;AAClD,SAAM;EACP,UAAS;AAER,SAAM,KAAK,QAAQ,KAAK,SAAS;EAClC;CACF;;;;;;;CAQD,MAAM,WAA0B;AAC9B,MAAI;GACF,MAAM,CAAC,SAAS,WAAW,GAAG,MAAM,KAAK,QAAQ,KAAK,QAAQ,UAAU;AAExE,OAAI,WAAW,SAAS,GAAG;AACzB,WAAO,KACJ,oBAAoB,QAAQ,QAAQ,WAAW,OAAO,cACxD;AACD,eAAW,QAAQ,CAACA,cAAsB;AACxC,YAAO,KAAK,MAAM,UAAU,EAAE;IAC/B,EAAC;GACH,MACC,QAAO,IAAI,4BAA4B;EAE1C,SAAQ,OAAO;AACd,UAAO,MAAM,kCAAkC,MAAM;AACrD,SAAM;EACP,UAAS;AACR,SAAM,KAAK,QAAQ,KAAK,SAAS;EAClC;CACF;;;;;;;CAQD,MAAM,SAGH;AACD,MAAI;GACF,MAAM,YAAY,MAAM,KAAK,QAAQ,KAAK,QAAQ,MAAM;GACxD,MAAM,GAAG,QAAQ,GAAG,MAAM,KAAK,QAAQ,KAAK,QAAQ,gBAAgB;AAEpE,UAAO;IACL,WAAW,MAAM,QAAQ,UAAU,GAAG,GAAG,UAAU,KAAK,CAAE;IAC1D,SAAS,MAAM,QAAQ,QAAQ,GAAG,UAAU,CAAE;GAC/C;EACF,UAAS;AACR,SAAM,KAAK,QAAQ,KAAK,SAAS;EAClC;CACF;AACF"}

package/dist/PostgresObjectionMigrator-CZHHcCOv.d.cts

@@ -74,4 +74,5 @@ declare class PostgresObjectionMigrator extends PostgresMigrator {
   }>;
 }
 //#endregion
-export { PostgresObjectionMigrator };
+export { PostgresObjectionMigrator };
+//# sourceMappingURL=PostgresObjectionMigrator-CZHHcCOv.d.cts.map