@geekmidas/testkit 0.0.17 → 0.1.1

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

@@ -1,5 +1,5 @@
-import { FakerFactory } from "./faker-Cg76aFNO.cjs";
-import { Factory, FactorySeed } from "./Factory-BZ8uMoXl.cjs";
+import { FakerFactory } from "./faker-BSH1EMtg.cjs";
+import { Factory, FactorySeed } from "./Factory-pNV7ZQ7-.cjs";
 import { Knex } from "knex";
 import { Model } from "objection";
 
@@ -21,17 +21,17 @@ import { Model } from "objection";
  *
  * // Create builders
  * const builders = {
- *   user: (attrs) => User.fromJson({
+ *   user: ObjectionFactory.createBuilder(User, ({ attrs, faker }) => ({
  *     id: faker.string.uuid(),
  *     name: faker.person.fullName(),
  *     email: faker.internet.email(),
  *     ...attrs
- *   }),
- *   post: (attrs) => Post.fromJson({
+ *   })),
+ *   post: ObjectionFactory.createBuilder(Post, ({ attrs }) => ({
  *     title: 'Test Post',
  *     content: 'Test content',
  *     ...attrs
- *   })
+ *   })),
  * };
  *
  * // Create factory instance
@@ -64,15 +64,15 @@ declare class ObjectionFactory<Builders extends Record<string, any>, Seeds exten
    * @template Result - The result type (defaults to the model instance)
    *
    * @param ModelClass - The Objection.js Model class
-   * @param item - Optional function to provide default values and transformations
+   * @param defaults - Optional function to provide default values (receives destructured context)
    * @param autoInsert - Whether to automatically insert the record (default: true)
    * @returns A builder function that creates and optionally inserts records
    *
    * @example
    * ```typescript
-   * // Create a simple builder with defaults
+   * // Create a simple builder with defaults - destructure only what you need
    * const userBuilder = ObjectionFactory.createBuilder(User,
-   *   (attrs, factory, db, faker) => ({
+   *   ({ attrs, faker }) => ({
    *     id: faker.string.uuid(),
    *     name: faker.person.fullName(),
    *     email: faker.internet.email(),
@@ -81,9 +81,17 @@ declare class ObjectionFactory<Builders extends Record<string, any>, Seeds exten
    *   })
    * );
    *
+   * // Only need faker? Just destructure that
+   * const leaveTypeBuilder = ObjectionFactory.createBuilder(LeaveType,
+   *   ({ faker }) => ({
+   *     name: faker.helpers.arrayElement(['Annual', 'Sick', 'Maternity']),
+   *     code: faker.string.alpha({ length: 3, casing: 'upper' }),
+   *   })
+   * );
+   *
    * // Create a builder that doesn't auto-insert (useful for nested inserts)
    * const addressBuilder = ObjectionFactory.createBuilder(Address,
-   *   (attrs) => ({
+   *   ({ attrs }) => ({
    *     street: '123 Main St',
    *     city: 'Anytown',
    *     ...attrs
@@ -93,7 +101,7 @@ declare class ObjectionFactory<Builders extends Record<string, any>, Seeds exten
    *
    * // Use with relations
    * const postBuilder = ObjectionFactory.createBuilder(Post,
-   *   async (attrs, factory) => ({
+   *   async ({ attrs, factory, faker }) => ({
    *     title: faker.lorem.sentence(),
    *     content: faker.lorem.paragraphs(),
    *     authorId: attrs.authorId || (await factory.insert('user')).id,
@@ -102,7 +110,12 @@ declare class ObjectionFactory<Builders extends Record<string, any>, Seeds exten
    * );
    * ```
    */
-  static createBuilder<TModel extends typeof Model, Attrs extends Partial<InstanceType<TModel>> = Partial<InstanceType<TModel>>, Factory = any, Result = InstanceType<TModel>>(ModelClass: TModel, item?: (attrs: Attrs, factory: Factory, db: Knex, faker: FakerFactory) => Partial<InstanceType<TModel>> | Promise<Partial<InstanceType<TModel>>>, autoInsert?: boolean): (attrs: Attrs, factory: Factory, db: Knex, faker: FakerFactory) => Promise<Result>;
+  static createBuilder<TModel extends typeof Model, Attrs extends Partial<InstanceType<TModel>> = Partial<InstanceType<TModel>>, Factory = any, Result = InstanceType<TModel>>(ModelClass: TModel, defaults?: (context: {
+    attrs: Attrs;
+    factory: Factory;
+    db: Knex;
+    faker: FakerFactory;
+  }) => Partial<InstanceType<TModel>> | Promise<Partial<InstanceType<TModel>>>, autoInsert?: boolean): (attrs: Attrs, factory: Factory, db: Knex, faker: FakerFactory) => Promise<Result>;
   /**
    * Creates a new ObjectionFactory instance.
    *
@@ -211,4 +224,4 @@ declare class ObjectionFactory<Builders extends Record<string, any>, Seeds exten
 }
 //#endregion
 export { ObjectionFactory };
-//# sourceMappingURL=ObjectionFactory-C4X78k0B.d.cts.map
+//# sourceMappingURL=ObjectionFactory-BwpN4gMX.d.cts.map

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

@@ -18,17 +18,17 @@ const require_faker = require('./faker-B14IEMIN.cjs');
 *
 * // Create builders
 * const builders = {
-*   user: (attrs) => User.fromJson({
+*   user: ObjectionFactory.createBuilder(User, ({ attrs, faker }) => ({
 *     id: faker.string.uuid(),
 *     name: faker.person.fullName(),
 *     email: faker.internet.email(),
 *     ...attrs
-*   }),
-*   post: (attrs) => Post.fromJson({
+*   })),
+*   post: ObjectionFactory.createBuilder(Post, ({ attrs }) => ({
 *     title: 'Test Post',
 *     content: 'Test content',
 *     ...attrs
-*   })
+*   })),
 * };
 *
 * // Create factory instance
@@ -60,15 +60,15 @@ var ObjectionFactory = class extends require_Factory.Factory {
 	* @template Result - The result type (defaults to the model instance)
 	*
 	* @param ModelClass - The Objection.js Model class
-	* @param item - Optional function to provide default values and transformations
+	* @param defaults - Optional function to provide default values (receives destructured context)
 	* @param autoInsert - Whether to automatically insert the record (default: true)
 	* @returns A builder function that creates and optionally inserts records
 	*
 	* @example
 	* ```typescript
-	* // Create a simple builder with defaults
+	* // Create a simple builder with defaults - destructure only what you need
 	* const userBuilder = ObjectionFactory.createBuilder(User,
-	*   (attrs, factory, db, faker) => ({
+	*   ({ attrs, faker }) => ({
 	*     id: faker.string.uuid(),
 	*     name: faker.person.fullName(),
 	*     email: faker.internet.email(),
@@ -77,9 +77,17 @@ var ObjectionFactory = class extends require_Factory.Factory {
 	*   })
 	* );
 	*
+	* // Only need faker? Just destructure that
+	* const leaveTypeBuilder = ObjectionFactory.createBuilder(LeaveType,
+	*   ({ faker }) => ({
+	*     name: faker.helpers.arrayElement(['Annual', 'Sick', 'Maternity']),
+	*     code: faker.string.alpha({ length: 3, casing: 'upper' }),
+	*   })
+	* );
+	*
 	* // Create a builder that doesn't auto-insert (useful for nested inserts)
 	* const addressBuilder = ObjectionFactory.createBuilder(Address,
-	*   (attrs) => ({
+	*   ({ attrs }) => ({
 	*     street: '123 Main St',
 	*     city: 'Anytown',
 	*     ...attrs
@@ -89,7 +97,7 @@ var ObjectionFactory = class extends require_Factory.Factory {
 	*
 	* // Use with relations
 	* const postBuilder = ObjectionFactory.createBuilder(Post,
-	*   async (attrs, factory) => ({
+	*   async ({ attrs, factory, faker }) => ({
 	*     title: faker.lorem.sentence(),
 	*     content: faker.lorem.paragraphs(),
 	*     authorId: attrs.authorId || (await factory.insert('user')).id,
@@ -98,13 +106,18 @@ var ObjectionFactory = class extends require_Factory.Factory {
 	* );
 	* ```
 	*/
-	static createBuilder(ModelClass, item, autoInsert) {
-		return async (attrs, factory, db, faker$1) => {
+	static createBuilder(ModelClass, defaults, autoInsert) {
+		return async (attrs, factory, db, fakerInstance) => {
 			let data = { ...attrs };
-			if (item) {
-				const defaults = await item(attrs, factory, db, faker$1);
+			if (defaults) {
+				const defaultValues = await defaults({
+					attrs,
+					factory,
+					db,
+					faker: fakerInstance
+				});
 				data = {
-					...defaults,
+					...defaultValues,
 					...data
 				};
 			}
@@ -239,4 +252,4 @@ Object.defineProperty(exports, 'ObjectionFactory', {
     return ObjectionFactory;
   }
 });
-//# sourceMappingURL=ObjectionFactory-CDriunkS.cjs.map
+//# sourceMappingURL=ObjectionFactory-Eb04AOnv.cjs.map

package/dist/ObjectionFactory-Eb04AOnv.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"ObjectionFactory-Eb04AOnv.cjs","names":["Factory","seedFn: Seed","ModelClass: TModel","defaults?: (context: {\n      attrs: Attrs;\n      factory: Factory;\n      db: Knex;\n      faker: FakerFactory;\n    }) =>\n      | Partial<InstanceType<TModel>>\n      | Promise<Partial<InstanceType<TModel>>>","autoInsert?: boolean","attrs: Attrs","factory: Factory","db: Knex","fakerInstance: FakerFactory","data: Partial<InstanceType<TModel>>","builders: Builders","seeds: Seeds","builderName: K","attrs?: Parameters<Builders[K]>[0]","faker","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: ObjectionFactory.createBuilder(User, ({ attrs, faker }) => ({\n *     id: faker.string.uuid(),\n *     name: faker.person.fullName(),\n *     email: faker.internet.email(),\n *     ...attrs\n *   })),\n *   post: ObjectionFactory.createBuilder(Post, ({ attrs }) => ({\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 defaults - Optional function to provide default values (receives destructured context)\n   * @param autoInsert - Whether to automatically insert the record (default: true)\n   * @returns A builder function that creates and optionally inserts records\n   *\n   * @example\n   * ```typescript\n   * // Create a simple builder with defaults - destructure only what you need\n   * const userBuilder = ObjectionFactory.createBuilder(User,\n   *   ({ attrs, faker }) => ({\n   *     id: faker.string.uuid(),\n   *     name: faker.person.fullName(),\n   *     email: faker.internet.email(),\n   *     createdAt: new Date(),\n   *     ...attrs\n   *   })\n   * );\n   *\n   * // Only need faker? Just destructure that\n   * const leaveTypeBuilder = ObjectionFactory.createBuilder(LeaveType,\n   *   ({ faker }) => ({\n   *     name: faker.helpers.arrayElement(['Annual', 'Sick', 'Maternity']),\n   *     code: faker.string.alpha({ length: 3, casing: 'upper' }),\n   *   })\n   * );\n   *\n   * // Create a builder that doesn't auto-insert (useful for nested inserts)\n   * const addressBuilder = 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, faker }) => ({\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    defaults?: (context: {\n      attrs: Attrs;\n      factory: Factory;\n      db: Knex;\n      faker: FakerFactory;\n    }) =>\n      | Partial<InstanceType<TModel>>\n      | 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      fakerInstance: FakerFactory,\n    ) => {\n      // Start with attributes\n      let data: Partial<InstanceType<TModel>> = { ...attrs };\n\n      // Apply defaults\n      if (defaults) {\n        const defaultValues = await defaults({\n          attrs,\n          factory,\n          db,\n          faker: fakerInstance,\n        });\n        data = { ...defaultValues, ...data };\n      }\n\n      // 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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA0DD,OAAO,cAMLC,YACAC,UAQAC,YAMmB;AACnB,SAAO,OACLC,OACAC,SACAC,IACAC,kBACG;GAEH,IAAIC,OAAsC,EAAE,GAAG,MAAO;AAGtD,OAAI,UAAU;IACZ,MAAM,gBAAgB,MAAM,SAAS;KACnC;KACA;KACA;KACA,OAAO;IACR,EAAC;AACF,WAAO;KAAE,GAAG;KAAe,GAAG;IAAM;GACrC;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,OACAJ,IACR;AACA,SAAO;EAJC;EACA;EACA;CAGT;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAiCD,MAAM,OACJK,aACAC,OAC2C;AAC3C,QAAM,eAAe,KAAK,UACxB,OAAM,IAAI,OACP,WACC,YACD;EAIL,MAAM,SAAS,MAAM,KAAK,SAAS,aACjC,SAAS,CAAE,GACX,MACA,KAAK,IACLC,oBACD;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,OACAH,aACAI,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,GAAGH,oBAAM,GAAG;AAEjE,WAAQ,KACN,KAAK,SAAS,aAAa,UAAU,MAAM,KAAK,IAAIA,oBAAM,CAAC,KACzD,CAACI,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-8hebmnai.mjs → ObjectionFactory-zf2fLKrL.mjs}

@@ -18,17 +18,17 @@ import { faker } from "./faker-BGKYFoCT.mjs";
 *
 * // Create builders
 * const builders = {
-*   user: (attrs) => User.fromJson({
+*   user: ObjectionFactory.createBuilder(User, ({ attrs, faker }) => ({
 *     id: faker.string.uuid(),
 *     name: faker.person.fullName(),
 *     email: faker.internet.email(),
 *     ...attrs
-*   }),
-*   post: (attrs) => Post.fromJson({
+*   })),
+*   post: ObjectionFactory.createBuilder(Post, ({ attrs }) => ({
 *     title: 'Test Post',
 *     content: 'Test content',
 *     ...attrs
-*   })
+*   })),
 * };
 *
 * // Create factory instance
@@ -60,15 +60,15 @@ var ObjectionFactory = class extends Factory {
 	* @template Result - The result type (defaults to the model instance)
 	*
 	* @param ModelClass - The Objection.js Model class
-	* @param item - Optional function to provide default values and transformations
+	* @param defaults - Optional function to provide default values (receives destructured context)
 	* @param autoInsert - Whether to automatically insert the record (default: true)
 	* @returns A builder function that creates and optionally inserts records
 	*
 	* @example
 	* ```typescript
-	* // Create a simple builder with defaults
+	* // Create a simple builder with defaults - destructure only what you need
 	* const userBuilder = ObjectionFactory.createBuilder(User,
-	*   (attrs, factory, db, faker) => ({
+	*   ({ attrs, faker }) => ({
 	*     id: faker.string.uuid(),
 	*     name: faker.person.fullName(),
 	*     email: faker.internet.email(),
@@ -77,9 +77,17 @@ var ObjectionFactory = class extends Factory {
 	*   })
 	* );
 	*
+	* // Only need faker? Just destructure that
+	* const leaveTypeBuilder = ObjectionFactory.createBuilder(LeaveType,
+	*   ({ faker }) => ({
+	*     name: faker.helpers.arrayElement(['Annual', 'Sick', 'Maternity']),
+	*     code: faker.string.alpha({ length: 3, casing: 'upper' }),
+	*   })
+	* );
+	*
 	* // Create a builder that doesn't auto-insert (useful for nested inserts)
 	* const addressBuilder = ObjectionFactory.createBuilder(Address,
-	*   (attrs) => ({
+	*   ({ attrs }) => ({
 	*     street: '123 Main St',
 	*     city: 'Anytown',
 	*     ...attrs
@@ -89,7 +97,7 @@ var ObjectionFactory = class extends Factory {
 	*
 	* // Use with relations
 	* const postBuilder = ObjectionFactory.createBuilder(Post,
-	*   async (attrs, factory) => ({
+	*   async ({ attrs, factory, faker }) => ({
 	*     title: faker.lorem.sentence(),
 	*     content: faker.lorem.paragraphs(),
 	*     authorId: attrs.authorId || (await factory.insert('user')).id,
@@ -98,13 +106,18 @@ var ObjectionFactory = class extends Factory {
 	* );
 	* ```
 	*/
-	static createBuilder(ModelClass, item, autoInsert) {
-		return async (attrs, factory, db, faker$1) => {
+	static createBuilder(ModelClass, defaults, autoInsert) {
+		return async (attrs, factory, db, fakerInstance) => {
 			let data = { ...attrs };
-			if (item) {
-				const defaults = await item(attrs, factory, db, faker$1);
+			if (defaults) {
+				const defaultValues = await defaults({
+					attrs,
+					factory,
+					db,
+					faker: fakerInstance
+				});
 				data = {
-					...defaults,
+					...defaultValues,
 					...data
 				};
 			}
@@ -234,4 +247,4 @@ var ObjectionFactory = class extends Factory {
 
 //#endregion
 export { ObjectionFactory };
-//# sourceMappingURL=ObjectionFactory-8hebmnai.mjs.map
+//# sourceMappingURL=ObjectionFactory-zf2fLKrL.mjs.map

package/dist/ObjectionFactory-zf2fLKrL.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"ObjectionFactory-zf2fLKrL.mjs","names":["seedFn: Seed","ModelClass: TModel","defaults?: (context: {\n      attrs: Attrs;\n      factory: Factory;\n      db: Knex;\n      faker: FakerFactory;\n    }) =>\n      | Partial<InstanceType<TModel>>\n      | Promise<Partial<InstanceType<TModel>>>","autoInsert?: boolean","attrs: Attrs","factory: Factory","db: Knex","fakerInstance: FakerFactory","data: Partial<InstanceType<TModel>>","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: ObjectionFactory.createBuilder(User, ({ attrs, faker }) => ({\n *     id: faker.string.uuid(),\n *     name: faker.person.fullName(),\n *     email: faker.internet.email(),\n *     ...attrs\n *   })),\n *   post: ObjectionFactory.createBuilder(Post, ({ attrs }) => ({\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 defaults - Optional function to provide default values (receives destructured context)\n   * @param autoInsert - Whether to automatically insert the record (default: true)\n   * @returns A builder function that creates and optionally inserts records\n   *\n   * @example\n   * ```typescript\n   * // Create a simple builder with defaults - destructure only what you need\n   * const userBuilder = ObjectionFactory.createBuilder(User,\n   *   ({ attrs, faker }) => ({\n   *     id: faker.string.uuid(),\n   *     name: faker.person.fullName(),\n   *     email: faker.internet.email(),\n   *     createdAt: new Date(),\n   *     ...attrs\n   *   })\n   * );\n   *\n   * // Only need faker? Just destructure that\n   * const leaveTypeBuilder = ObjectionFactory.createBuilder(LeaveType,\n   *   ({ faker }) => ({\n   *     name: faker.helpers.arrayElement(['Annual', 'Sick', 'Maternity']),\n   *     code: faker.string.alpha({ length: 3, casing: 'upper' }),\n   *   })\n   * );\n   *\n   * // Create a builder that doesn't auto-insert (useful for nested inserts)\n   * const addressBuilder = 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, faker }) => ({\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    defaults?: (context: {\n      attrs: Attrs;\n      factory: Factory;\n      db: Knex;\n      faker: FakerFactory;\n    }) =>\n      | Partial<InstanceType<TModel>>\n      | 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      fakerInstance: FakerFactory,\n    ) => {\n      // Start with attributes\n      let data: Partial<InstanceType<TModel>> = { ...attrs };\n\n      // Apply defaults\n      if (defaults) {\n        const defaultValues = await defaults({\n          attrs,\n          factory,\n          db,\n          faker: fakerInstance,\n        });\n        data = { ...defaultValues, ...data };\n      }\n\n      // 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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA0DD,OAAO,cAMLC,YACAC,UAQAC,YAMmB;AACnB,SAAO,OACLC,OACAC,SACAC,IACAC,kBACG;GAEH,IAAIC,OAAsC,EAAE,GAAG,MAAO;AAGtD,OAAI,UAAU;IACZ,MAAM,gBAAgB,MAAM,SAAS;KACnC;KACA;KACA;KACA,OAAO;IACR,EAAC;AACF,WAAO;KAAE,GAAG;KAAe,GAAG;IAAM;GACrC;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,OACAJ,IACR;AACA,SAAO;EAJC;EACA;EACA;CAGT;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAiCD,MAAM,OACJK,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.cjs

@@ -1,5 +1,5 @@
 require('./Factory-WMhTNZ9S.cjs');
 require('./faker-B14IEMIN.cjs');
-const require_ObjectionFactory = require('./ObjectionFactory-CDriunkS.cjs');
+const require_ObjectionFactory = require('./ObjectionFactory-Eb04AOnv.cjs');
 
 exports.ObjectionFactory = require_ObjectionFactory.ObjectionFactory;

package/dist/ObjectionFactory.d.cts

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

package/dist/ObjectionFactory.d.mts

@@ -1,4 +1,4 @@
-import "./faker-Br8MzXil.mjs";
-import "./Factory-CRquB4vz.mjs";
-import { ObjectionFactory } from "./ObjectionFactory-C3tHvX1d.mjs";
+import "./faker-D9gz7KjY.mjs";
+import "./Factory-DE3hE0WO.mjs";
+import { ObjectionFactory } from "./ObjectionFactory-BlBicEia.mjs";
 export { ObjectionFactory };

package/dist/ObjectionFactory.mjs

@@ -1,5 +1,5 @@
 import "./Factory-z2m01hMj.mjs";
 import "./faker-BGKYFoCT.mjs";
-import { ObjectionFactory } from "./ObjectionFactory-8hebmnai.mjs";
+import { ObjectionFactory } from "./ObjectionFactory-zf2fLKrL.mjs";
 
 export { ObjectionFactory };

package/dist/{VitestKyselyTransactionIsolator-COCVfvfr.d.mts → VitestKyselyTransactionIsolator-BqrZDeaT.d.cts}

@@ -1,4 +1,4 @@
-import { IsolationLevel, VitestPostgresTransactionIsolator } from "./VitestTransactionIsolator-CsfJBxcb.mjs";
+import { IsolationLevel, VitestPostgresTransactionIsolator } from "./VitestTransactionIsolator-DfA80g2M.cjs";
 import { Kysely, Transaction } from "kysely";
 
 //#region src/VitestKyselyTransactionIsolator.d.ts
@@ -55,4 +55,4 @@ declare class VitestKyselyTransactionIsolator<Database> extends VitestPostgresTr
 }
 //#endregion
 export { VitestKyselyTransactionIsolator };
-//# sourceMappingURL=VitestKyselyTransactionIsolator-COCVfvfr.d.mts.map
+//# sourceMappingURL=VitestKyselyTransactionIsolator-BqrZDeaT.d.cts.map

package/dist/{VitestKyselyTransactionIsolator-Cst3vFjb.cjs → VitestKyselyTransactionIsolator-DX_VPKS-.cjs}

@@ -1,4 +1,4 @@
-const require_VitestTransactionIsolator = require('./VitestTransactionIsolator-BQ5FpLtC.cjs');
+const require_VitestTransactionIsolator = require('./VitestTransactionIsolator-BKIrj3Uy.cjs');
 
 //#region src/VitestKyselyTransactionIsolator.ts
 /**
@@ -62,4 +62,4 @@ Object.defineProperty(exports, 'VitestKyselyTransactionIsolator', {
     return VitestKyselyTransactionIsolator;
   }
 });
-//# sourceMappingURL=VitestKyselyTransactionIsolator-Cst3vFjb.cjs.map
+//# sourceMappingURL=VitestKyselyTransactionIsolator-DX_VPKS-.cjs.map

package/dist/{VitestKyselyTransactionIsolator-Cst3vFjb.cjs.map → VitestKyselyTransactionIsolator-DX_VPKS-.cjs.map}

@@ -1 +1 @@
-{"version":3,"file":"VitestKyselyTransactionIsolator-Cst3vFjb.cjs","names":["VitestPostgresTransactionIsolator","conn: Kysely<Database>","level: IsolationLevel","fn: (trx: Transaction<Database>) => Promise<void>"],"sources":["../src/VitestKyselyTransactionIsolator.ts"],"sourcesContent":["import type { Kysely, Transaction } from 'kysely';\nimport {\n  type IsolationLevel,\n  VitestPostgresTransactionIsolator,\n} from './VitestTransactionIsolator';\n\n/**\n * Kysely-specific implementation of the Vitest transaction isolator.\n * Provides automatic transaction rollback for test isolation using Kysely's transaction API.\n * Each test runs within a database transaction that is rolled back after completion,\n * ensuring a clean state between tests without the overhead of recreating data.\n *\n * @template Database - The database schema type\n *\n * @example\n * ```typescript\n * import { VitestKyselyTransactionIsolator } from '@geekmidas/testkit';\n * import { db } from './database';\n *\n * // Create isolator instance\n * const isolator = new VitestKyselyTransactionIsolator<Database>();\n *\n * // In your test setup\n * beforeEach(async () => {\n *   await isolator.start(db);\n * });\n *\n * afterEach(async () => {\n *   await isolator.rollback();\n * });\n *\n * // Tests run in isolated transactions\n * it('should create user', async () => {\n *   const user = await db.insertInto('users')\n *     .values({ name: 'Test User' })\n *     .returningAll()\n *     .executeTakeFirst();\n *\n *   expect(user).toBeDefined();\n *   // This data will be rolled back after the test\n * });\n * ```\n */\nexport class VitestKyselyTransactionIsolator<\n  Database,\n> extends VitestPostgresTransactionIsolator<\n  Kysely<Database>,\n  Transaction<Database>\n> {\n  async destroy(conn: Kysely<Database>): Promise<void> {\n    // return conn.destroy();\n  }\n  /**\n   * Creates a Kysely transaction with the specified isolation level.\n   * Implements the abstract transact method from VitestPostgresTransactionIsolator.\n   *\n   * @param conn - The Kysely database connection\n   * @param level - The transaction isolation level\n   * @param fn - The function to execute within the transaction\n   * @returns Promise that resolves when the transaction completes\n   */\n  async transact(\n    conn: Kysely<Database>,\n    level: IsolationLevel,\n    fn: (trx: Transaction<Database>) => Promise<void>,\n  ): Promise<void> {\n    const isolationLevel =\n      level.toLocaleLowerCase() as Lowercase<IsolationLevel>;\n    await conn.transaction().setIsolationLevel(isolationLevel).execute(fn);\n  }\n  // Implement any Kysely-specific transaction logic here\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA2CA,IAAa,kCAAb,cAEUA,oEAGR;CACA,MAAM,QAAQC,MAAuC,CAEpD;;;;;;;;;;CAUD,MAAM,SACJA,MACAC,OACAC,IACe;EACf,MAAM,iBACJ,MAAM,mBAAmB;AAC3B,QAAM,KAAK,aAAa,CAAC,kBAAkB,eAAe,CAAC,QAAQ,GAAG;CACvE;AAEF"}
+{"version":3,"file":"VitestKyselyTransactionIsolator-DX_VPKS-.cjs","names":["VitestPostgresTransactionIsolator","conn: Kysely<Database>","level: IsolationLevel","fn: (trx: Transaction<Database>) => Promise<void>"],"sources":["../src/VitestKyselyTransactionIsolator.ts"],"sourcesContent":["import type { Kysely, Transaction } from 'kysely';\nimport {\n  type IsolationLevel,\n  VitestPostgresTransactionIsolator,\n} from './VitestTransactionIsolator';\n\n/**\n * Kysely-specific implementation of the Vitest transaction isolator.\n * Provides automatic transaction rollback for test isolation using Kysely's transaction API.\n * Each test runs within a database transaction that is rolled back after completion,\n * ensuring a clean state between tests without the overhead of recreating data.\n *\n * @template Database - The database schema type\n *\n * @example\n * ```typescript\n * import { VitestKyselyTransactionIsolator } from '@geekmidas/testkit';\n * import { db } from './database';\n *\n * // Create isolator instance\n * const isolator = new VitestKyselyTransactionIsolator<Database>();\n *\n * // In your test setup\n * beforeEach(async () => {\n *   await isolator.start(db);\n * });\n *\n * afterEach(async () => {\n *   await isolator.rollback();\n * });\n *\n * // Tests run in isolated transactions\n * it('should create user', async () => {\n *   const user = await db.insertInto('users')\n *     .values({ name: 'Test User' })\n *     .returningAll()\n *     .executeTakeFirst();\n *\n *   expect(user).toBeDefined();\n *   // This data will be rolled back after the test\n * });\n * ```\n */\nexport class VitestKyselyTransactionIsolator<\n  Database,\n> extends VitestPostgresTransactionIsolator<\n  Kysely<Database>,\n  Transaction<Database>\n> {\n  async destroy(conn: Kysely<Database>): Promise<void> {\n    // return conn.destroy();\n  }\n  /**\n   * Creates a Kysely transaction with the specified isolation level.\n   * Implements the abstract transact method from VitestPostgresTransactionIsolator.\n   *\n   * @param conn - The Kysely database connection\n   * @param level - The transaction isolation level\n   * @param fn - The function to execute within the transaction\n   * @returns Promise that resolves when the transaction completes\n   */\n  async transact(\n    conn: Kysely<Database>,\n    level: IsolationLevel,\n    fn: (trx: Transaction<Database>) => Promise<void>,\n  ): Promise<void> {\n    const isolationLevel =\n      level.toLocaleLowerCase() as Lowercase<IsolationLevel>;\n    await conn.transaction().setIsolationLevel(isolationLevel).execute(fn);\n  }\n  // Implement any Kysely-specific transaction logic here\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA2CA,IAAa,kCAAb,cAEUA,oEAGR;CACA,MAAM,QAAQC,MAAuC,CAEpD;;;;;;;;;;CAUD,MAAM,SACJA,MACAC,OACAC,IACe;EACf,MAAM,iBACJ,MAAM,mBAAmB;AAC3B,QAAM,KAAK,aAAa,CAAC,kBAAkB,eAAe,CAAC,QAAQ,GAAG;CACvE;AAEF"}

package/dist/{VitestKyselyTransactionIsolator-DYUYVEh9.d.cts → VitestKyselyTransactionIsolator-DiskaURs.d.mts}

@@ -1,4 +1,4 @@
-import { IsolationLevel, VitestPostgresTransactionIsolator } from "./VitestTransactionIsolator-DdLNODZg.cjs";
+import { IsolationLevel, VitestPostgresTransactionIsolator } from "./VitestTransactionIsolator-DLdQlfZ5.mjs";
 import { Kysely, Transaction } from "kysely";
 
 //#region src/VitestKyselyTransactionIsolator.d.ts
@@ -55,4 +55,4 @@ declare class VitestKyselyTransactionIsolator<Database> extends VitestPostgresTr
 }
 //#endregion
 export { VitestKyselyTransactionIsolator };
-//# sourceMappingURL=VitestKyselyTransactionIsolator-DYUYVEh9.d.cts.map
+//# sourceMappingURL=VitestKyselyTransactionIsolator-DiskaURs.d.mts.map

package/dist/{VitestKyselyTransactionIsolator-BxjlD1YM.mjs → VitestKyselyTransactionIsolator-XDL3ngs_.mjs}

@@ -1,4 +1,4 @@
-import { VitestPostgresTransactionIsolator } from "./VitestTransactionIsolator-CskiiJbW.mjs";
+import { VitestPostgresTransactionIsolator } from "./VitestTransactionIsolator-BIaMs4c2.mjs";
 
 //#region src/VitestKyselyTransactionIsolator.ts
 /**
@@ -57,4 +57,4 @@ var VitestKyselyTransactionIsolator = class extends VitestPostgresTransactionIso
 
 //#endregion
 export { VitestKyselyTransactionIsolator };
-//# sourceMappingURL=VitestKyselyTransactionIsolator-BxjlD1YM.mjs.map
+//# sourceMappingURL=VitestKyselyTransactionIsolator-XDL3ngs_.mjs.map

package/dist/{VitestKyselyTransactionIsolator-BxjlD1YM.mjs.map → VitestKyselyTransactionIsolator-XDL3ngs_.mjs.map}

@@ -1 +1 @@
-{"version":3,"file":"VitestKyselyTransactionIsolator-BxjlD1YM.mjs","names":["conn: Kysely<Database>","level: IsolationLevel","fn: (trx: Transaction<Database>) => Promise<void>"],"sources":["../src/VitestKyselyTransactionIsolator.ts"],"sourcesContent":["import type { Kysely, Transaction } from 'kysely';\nimport {\n  type IsolationLevel,\n  VitestPostgresTransactionIsolator,\n} from './VitestTransactionIsolator';\n\n/**\n * Kysely-specific implementation of the Vitest transaction isolator.\n * Provides automatic transaction rollback for test isolation using Kysely's transaction API.\n * Each test runs within a database transaction that is rolled back after completion,\n * ensuring a clean state between tests without the overhead of recreating data.\n *\n * @template Database - The database schema type\n *\n * @example\n * ```typescript\n * import { VitestKyselyTransactionIsolator } from '@geekmidas/testkit';\n * import { db } from './database';\n *\n * // Create isolator instance\n * const isolator = new VitestKyselyTransactionIsolator<Database>();\n *\n * // In your test setup\n * beforeEach(async () => {\n *   await isolator.start(db);\n * });\n *\n * afterEach(async () => {\n *   await isolator.rollback();\n * });\n *\n * // Tests run in isolated transactions\n * it('should create user', async () => {\n *   const user = await db.insertInto('users')\n *     .values({ name: 'Test User' })\n *     .returningAll()\n *     .executeTakeFirst();\n *\n *   expect(user).toBeDefined();\n *   // This data will be rolled back after the test\n * });\n * ```\n */\nexport class VitestKyselyTransactionIsolator<\n  Database,\n> extends VitestPostgresTransactionIsolator<\n  Kysely<Database>,\n  Transaction<Database>\n> {\n  async destroy(conn: Kysely<Database>): Promise<void> {\n    // return conn.destroy();\n  }\n  /**\n   * Creates a Kysely transaction with the specified isolation level.\n   * Implements the abstract transact method from VitestPostgresTransactionIsolator.\n   *\n   * @param conn - The Kysely database connection\n   * @param level - The transaction isolation level\n   * @param fn - The function to execute within the transaction\n   * @returns Promise that resolves when the transaction completes\n   */\n  async transact(\n    conn: Kysely<Database>,\n    level: IsolationLevel,\n    fn: (trx: Transaction<Database>) => Promise<void>,\n  ): Promise<void> {\n    const isolationLevel =\n      level.toLocaleLowerCase() as Lowercase<IsolationLevel>;\n    await conn.transaction().setIsolationLevel(isolationLevel).execute(fn);\n  }\n  // Implement any Kysely-specific transaction logic here\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA2CA,IAAa,kCAAb,cAEU,kCAGR;CACA,MAAM,QAAQA,MAAuC,CAEpD;;;;;;;;;;CAUD,MAAM,SACJA,MACAC,OACAC,IACe;EACf,MAAM,iBACJ,MAAM,mBAAmB;AAC3B,QAAM,KAAK,aAAa,CAAC,kBAAkB,eAAe,CAAC,QAAQ,GAAG;CACvE;AAEF"}
+{"version":3,"file":"VitestKyselyTransactionIsolator-XDL3ngs_.mjs","names":["conn: Kysely<Database>","level: IsolationLevel","fn: (trx: Transaction<Database>) => Promise<void>"],"sources":["../src/VitestKyselyTransactionIsolator.ts"],"sourcesContent":["import type { Kysely, Transaction } from 'kysely';\nimport {\n  type IsolationLevel,\n  VitestPostgresTransactionIsolator,\n} from './VitestTransactionIsolator';\n\n/**\n * Kysely-specific implementation of the Vitest transaction isolator.\n * Provides automatic transaction rollback for test isolation using Kysely's transaction API.\n * Each test runs within a database transaction that is rolled back after completion,\n * ensuring a clean state between tests without the overhead of recreating data.\n *\n * @template Database - The database schema type\n *\n * @example\n * ```typescript\n * import { VitestKyselyTransactionIsolator } from '@geekmidas/testkit';\n * import { db } from './database';\n *\n * // Create isolator instance\n * const isolator = new VitestKyselyTransactionIsolator<Database>();\n *\n * // In your test setup\n * beforeEach(async () => {\n *   await isolator.start(db);\n * });\n *\n * afterEach(async () => {\n *   await isolator.rollback();\n * });\n *\n * // Tests run in isolated transactions\n * it('should create user', async () => {\n *   const user = await db.insertInto('users')\n *     .values({ name: 'Test User' })\n *     .returningAll()\n *     .executeTakeFirst();\n *\n *   expect(user).toBeDefined();\n *   // This data will be rolled back after the test\n * });\n * ```\n */\nexport class VitestKyselyTransactionIsolator<\n  Database,\n> extends VitestPostgresTransactionIsolator<\n  Kysely<Database>,\n  Transaction<Database>\n> {\n  async destroy(conn: Kysely<Database>): Promise<void> {\n    // return conn.destroy();\n  }\n  /**\n   * Creates a Kysely transaction with the specified isolation level.\n   * Implements the abstract transact method from VitestPostgresTransactionIsolator.\n   *\n   * @param conn - The Kysely database connection\n   * @param level - The transaction isolation level\n   * @param fn - The function to execute within the transaction\n   * @returns Promise that resolves when the transaction completes\n   */\n  async transact(\n    conn: Kysely<Database>,\n    level: IsolationLevel,\n    fn: (trx: Transaction<Database>) => Promise<void>,\n  ): Promise<void> {\n    const isolationLevel =\n      level.toLocaleLowerCase() as Lowercase<IsolationLevel>;\n    await conn.transaction().setIsolationLevel(isolationLevel).execute(fn);\n  }\n  // Implement any Kysely-specific transaction logic here\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA2CA,IAAa,kCAAb,cAEU,kCAGR;CACA,MAAM,QAAQA,MAAuC,CAEpD;;;;;;;;;;CAUD,MAAM,SACJA,MACAC,OACAC,IACe;EACf,MAAM,iBACJ,MAAM,mBAAmB;AAC3B,QAAM,KAAK,aAAa,CAAC,kBAAkB,eAAe,CAAC,QAAQ,GAAG;CACvE;AAEF"}

package/dist/VitestKyselyTransactionIsolator.cjs

@@ -1,4 +1,4 @@
-require('./VitestTransactionIsolator-BQ5FpLtC.cjs');
-const require_VitestKyselyTransactionIsolator = require('./VitestKyselyTransactionIsolator-Cst3vFjb.cjs');
+require('./VitestTransactionIsolator-BKIrj3Uy.cjs');
+const require_VitestKyselyTransactionIsolator = require('./VitestKyselyTransactionIsolator-DX_VPKS-.cjs');
 
 exports.VitestKyselyTransactionIsolator = require_VitestKyselyTransactionIsolator.VitestKyselyTransactionIsolator;

package/dist/VitestKyselyTransactionIsolator.d.cts

@@ -1,3 +1,3 @@
-import "./VitestTransactionIsolator-DdLNODZg.cjs";
-import { VitestKyselyTransactionIsolator } from "./VitestKyselyTransactionIsolator-DYUYVEh9.cjs";
+import "./VitestTransactionIsolator-DfA80g2M.cjs";
+import { VitestKyselyTransactionIsolator } from "./VitestKyselyTransactionIsolator-BqrZDeaT.cjs";
 export { VitestKyselyTransactionIsolator };

package/dist/VitestKyselyTransactionIsolator.d.mts

@@ -1,3 +1,3 @@
-import "./VitestTransactionIsolator-CsfJBxcb.mjs";
-import { VitestKyselyTransactionIsolator } from "./VitestKyselyTransactionIsolator-COCVfvfr.mjs";
+import "./VitestTransactionIsolator-DLdQlfZ5.mjs";
+import { VitestKyselyTransactionIsolator } from "./VitestKyselyTransactionIsolator-DiskaURs.mjs";
 export { VitestKyselyTransactionIsolator };

package/dist/VitestKyselyTransactionIsolator.mjs

@@ -1,4 +1,4 @@
-import "./VitestTransactionIsolator-CskiiJbW.mjs";
-import { VitestKyselyTransactionIsolator } from "./VitestKyselyTransactionIsolator-BxjlD1YM.mjs";
+import "./VitestTransactionIsolator-BIaMs4c2.mjs";
+import { VitestKyselyTransactionIsolator } from "./VitestKyselyTransactionIsolator-XDL3ngs_.mjs";
 
 export { VitestKyselyTransactionIsolator };

package/dist/{VitestObjectionTransactionIsolator-b973r9O1.d.mts → VitestObjectionTransactionIsolator-CD2ucJpH.d.cts}

@@ -1,4 +1,4 @@
-import { IsolationLevel, VitestPostgresTransactionIsolator } from "./VitestTransactionIsolator-CsfJBxcb.mjs";
+import { IsolationLevel, VitestPostgresTransactionIsolator } from "./VitestTransactionIsolator-DfA80g2M.cjs";
 import { Knex } from "knex";
 
 //#region src/VitestObjectionTransactionIsolator.d.ts
@@ -56,4 +56,4 @@ declare class VitestObjectionTransactionIsolator extends VitestPostgresTransacti
 }
 //#endregion
 export { VitestObjectionTransactionIsolator };
-//# sourceMappingURL=VitestObjectionTransactionIsolator-b973r9O1.d.mts.map
+//# sourceMappingURL=VitestObjectionTransactionIsolator-CD2ucJpH.d.cts.map

package/dist/{VitestObjectionTransactionIsolator-DzeF4UAq.cjs → VitestObjectionTransactionIsolator-D_tlOtq8.cjs}

@@ -1,4 +1,4 @@
-const require_VitestTransactionIsolator = require('./VitestTransactionIsolator-BQ5FpLtC.cjs');
+const require_VitestTransactionIsolator = require('./VitestTransactionIsolator-BKIrj3Uy.cjs');
 
 //#region src/VitestObjectionTransactionIsolator.ts
 /**
@@ -65,4 +65,4 @@ Object.defineProperty(exports, 'VitestObjectionTransactionIsolator', {
     return VitestObjectionTransactionIsolator;
   }
 });
-//# sourceMappingURL=VitestObjectionTransactionIsolator-DzeF4UAq.cjs.map
+//# sourceMappingURL=VitestObjectionTransactionIsolator-D_tlOtq8.cjs.map

package/dist/{VitestObjectionTransactionIsolator-DzeF4UAq.cjs.map → VitestObjectionTransactionIsolator-D_tlOtq8.cjs.map}

@@ -1 +1 @@
-{"version":3,"file":"VitestObjectionTransactionIsolator-DzeF4UAq.cjs","names":["VitestPostgresTransactionIsolator","conn: Knex<any, any[]>","connection: Knex","level: IsolationLevel","fn: (trx: Knex.Transaction) => Promise<void>"],"sources":["../src/VitestObjectionTransactionIsolator.ts"],"sourcesContent":["import type { Knex } from 'knex';\nimport {\n  type IsolationLevel,\n  VitestPostgresTransactionIsolator,\n} from './VitestTransactionIsolator';\n\n/**\n * Objection.js-specific implementation of the Vitest transaction isolator.\n * Provides automatic transaction rollback for test isolation using Objection.js and Knex transaction API.\n * Each test runs within a database transaction that is rolled back after completion,\n * ensuring a clean state between tests without the overhead of recreating data.\n *\n * @example\n * ```typescript\n * import { VitestObjectionTransactionIsolator } from '@geekmidas/testkit';\n * import { knex } from './database';\n * import { User } from './models';\n * import { test } from 'vitest';\n *\n * // Create isolator instance\n * const isolator = new VitestObjectionTransactionIsolator(test);\n *\n * // Use with wrapped test API\n * const isolatedTest = isolator.wrapVitestWithTransaction(knex);\n *\n * isolatedTest('should create user', async ({ trx }) => {\n *   const user = await User.query(trx)\n *     .insert({ name: 'Test User' });\n *\n *   expect(user).toBeDefined();\n *   // This data will be rolled back after the test\n * });\n * ```\n */\nexport class VitestObjectionTransactionIsolator extends VitestPostgresTransactionIsolator<\n  Knex,\n  Knex.Transaction\n> {\n  async destroy(conn: Knex<any, any[]>): Promise<void> {}\n  /**\n   * Creates a Knex transaction with the specified isolation level.\n   * Implements the abstract transact method from VitestPostgresTransactionIsolator.\n   * This transaction can be used with Objection.js models via Model.query(trx).\n   *\n   * @param conn - The Knex database connection\n   * @param level - The transaction isolation level\n   * @param fn - The function to execute within the transaction\n   * @returns Promise that resolves when the transaction completes\n   *\n   * @example\n   * ```typescript\n   * await isolator.transact(knex, IsolationLevel.REPEATABLE_READ, async (trx) => {\n   *   // Use transaction with Objection models\n   *   await User.query(trx).insert({ name: 'Test' });\n   *   await Post.query(trx).where('userId', user.id).delete();\n   * });\n   * ```\n   */\n  async transact(\n    connection: Knex,\n    level: IsolationLevel,\n    fn: (trx: Knex.Transaction) => Promise<void>,\n  ): Promise<void> {\n    const isolationLevel = level.toLowerCase() as Lowercase<IsolationLevel>;\n\n    await connection.transaction(\n      async (trx) => {\n        await fn(trx);\n      },\n      {\n        isolationLevel,\n      },\n    );\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkCA,IAAa,qCAAb,cAAwDA,oEAGtD;CACA,MAAM,QAAQC,MAAuC,CAAE;;;;;;;;;;;;;;;;;;;;CAoBvD,MAAM,SACJC,YACAC,OACAC,IACe;EACf,MAAM,iBAAiB,MAAM,aAAa;AAE1C,QAAM,WAAW,YACf,OAAO,QAAQ;AACb,SAAM,GAAG,IAAI;EACd,GACD,EACE,eACD,EACF;CACF;AACF"}
+{"version":3,"file":"VitestObjectionTransactionIsolator-D_tlOtq8.cjs","names":["VitestPostgresTransactionIsolator","conn: Knex<any, any[]>","connection: Knex","level: IsolationLevel","fn: (trx: Knex.Transaction) => Promise<void>"],"sources":["../src/VitestObjectionTransactionIsolator.ts"],"sourcesContent":["import type { Knex } from 'knex';\nimport {\n  type IsolationLevel,\n  VitestPostgresTransactionIsolator,\n} from './VitestTransactionIsolator';\n\n/**\n * Objection.js-specific implementation of the Vitest transaction isolator.\n * Provides automatic transaction rollback for test isolation using Objection.js and Knex transaction API.\n * Each test runs within a database transaction that is rolled back after completion,\n * ensuring a clean state between tests without the overhead of recreating data.\n *\n * @example\n * ```typescript\n * import { VitestObjectionTransactionIsolator } from '@geekmidas/testkit';\n * import { knex } from './database';\n * import { User } from './models';\n * import { test } from 'vitest';\n *\n * // Create isolator instance\n * const isolator = new VitestObjectionTransactionIsolator(test);\n *\n * // Use with wrapped test API\n * const isolatedTest = isolator.wrapVitestWithTransaction(knex);\n *\n * isolatedTest('should create user', async ({ trx }) => {\n *   const user = await User.query(trx)\n *     .insert({ name: 'Test User' });\n *\n *   expect(user).toBeDefined();\n *   // This data will be rolled back after the test\n * });\n * ```\n */\nexport class VitestObjectionTransactionIsolator extends VitestPostgresTransactionIsolator<\n  Knex,\n  Knex.Transaction\n> {\n  async destroy(conn: Knex<any, any[]>): Promise<void> {}\n  /**\n   * Creates a Knex transaction with the specified isolation level.\n   * Implements the abstract transact method from VitestPostgresTransactionIsolator.\n   * This transaction can be used with Objection.js models via Model.query(trx).\n   *\n   * @param conn - The Knex database connection\n   * @param level - The transaction isolation level\n   * @param fn - The function to execute within the transaction\n   * @returns Promise that resolves when the transaction completes\n   *\n   * @example\n   * ```typescript\n   * await isolator.transact(knex, IsolationLevel.REPEATABLE_READ, async (trx) => {\n   *   // Use transaction with Objection models\n   *   await User.query(trx).insert({ name: 'Test' });\n   *   await Post.query(trx).where('userId', user.id).delete();\n   * });\n   * ```\n   */\n  async transact(\n    connection: Knex,\n    level: IsolationLevel,\n    fn: (trx: Knex.Transaction) => Promise<void>,\n  ): Promise<void> {\n    const isolationLevel = level.toLowerCase() as Lowercase<IsolationLevel>;\n\n    await connection.transaction(\n      async (trx) => {\n        await fn(trx);\n      },\n      {\n        isolationLevel,\n      },\n    );\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkCA,IAAa,qCAAb,cAAwDA,oEAGtD;CACA,MAAM,QAAQC,MAAuC,CAAE;;;;;;;;;;;;;;;;;;;;CAoBvD,MAAM,SACJC,YACAC,OACAC,IACe;EACf,MAAM,iBAAiB,MAAM,aAAa;AAE1C,QAAM,WAAW,YACf,OAAO,QAAQ;AACb,SAAM,GAAG,IAAI;EACd,GACD,EACE,eACD,EACF;CACF;AACF"}

package/dist/{VitestObjectionTransactionIsolator-CJ4ds5Qv.d.cts → VitestObjectionTransactionIsolator-DhQ8XGva.d.mts}

@@ -1,4 +1,4 @@
-import { IsolationLevel, VitestPostgresTransactionIsolator } from "./VitestTransactionIsolator-DdLNODZg.cjs";
+import { IsolationLevel, VitestPostgresTransactionIsolator } from "./VitestTransactionIsolator-DLdQlfZ5.mjs";
 import { Knex } from "knex";
 
 //#region src/VitestObjectionTransactionIsolator.d.ts
@@ -56,4 +56,4 @@ declare class VitestObjectionTransactionIsolator extends VitestPostgresTransacti
 }
 //#endregion
 export { VitestObjectionTransactionIsolator };
-//# sourceMappingURL=VitestObjectionTransactionIsolator-CJ4ds5Qv.d.cts.map
+//# sourceMappingURL=VitestObjectionTransactionIsolator-DhQ8XGva.d.mts.map

package/dist/{VitestObjectionTransactionIsolator-BU-jXEhz.mjs → VitestObjectionTransactionIsolator-_EhJKu_O.mjs}

@@ -1,4 +1,4 @@
-import { VitestPostgresTransactionIsolator } from "./VitestTransactionIsolator-CskiiJbW.mjs";
+import { VitestPostgresTransactionIsolator } from "./VitestTransactionIsolator-BIaMs4c2.mjs";
 
 //#region src/VitestObjectionTransactionIsolator.ts
 /**
@@ -60,4 +60,4 @@ var VitestObjectionTransactionIsolator = class extends VitestPostgresTransaction
 
 //#endregion
 export { VitestObjectionTransactionIsolator };
-//# sourceMappingURL=VitestObjectionTransactionIsolator-BU-jXEhz.mjs.map
+//# sourceMappingURL=VitestObjectionTransactionIsolator-_EhJKu_O.mjs.map

package/dist/{VitestObjectionTransactionIsolator-BU-jXEhz.mjs.map → VitestObjectionTransactionIsolator-_EhJKu_O.mjs.map}

@@ -1 +1 @@
-{"version":3,"file":"VitestObjectionTransactionIsolator-BU-jXEhz.mjs","names":["conn: Knex<any, any[]>","connection: Knex","level: IsolationLevel","fn: (trx: Knex.Transaction) => Promise<void>"],"sources":["../src/VitestObjectionTransactionIsolator.ts"],"sourcesContent":["import type { Knex } from 'knex';\nimport {\n  type IsolationLevel,\n  VitestPostgresTransactionIsolator,\n} from './VitestTransactionIsolator';\n\n/**\n * Objection.js-specific implementation of the Vitest transaction isolator.\n * Provides automatic transaction rollback for test isolation using Objection.js and Knex transaction API.\n * Each test runs within a database transaction that is rolled back after completion,\n * ensuring a clean state between tests without the overhead of recreating data.\n *\n * @example\n * ```typescript\n * import { VitestObjectionTransactionIsolator } from '@geekmidas/testkit';\n * import { knex } from './database';\n * import { User } from './models';\n * import { test } from 'vitest';\n *\n * // Create isolator instance\n * const isolator = new VitestObjectionTransactionIsolator(test);\n *\n * // Use with wrapped test API\n * const isolatedTest = isolator.wrapVitestWithTransaction(knex);\n *\n * isolatedTest('should create user', async ({ trx }) => {\n *   const user = await User.query(trx)\n *     .insert({ name: 'Test User' });\n *\n *   expect(user).toBeDefined();\n *   // This data will be rolled back after the test\n * });\n * ```\n */\nexport class VitestObjectionTransactionIsolator extends VitestPostgresTransactionIsolator<\n  Knex,\n  Knex.Transaction\n> {\n  async destroy(conn: Knex<any, any[]>): Promise<void> {}\n  /**\n   * Creates a Knex transaction with the specified isolation level.\n   * Implements the abstract transact method from VitestPostgresTransactionIsolator.\n   * This transaction can be used with Objection.js models via Model.query(trx).\n   *\n   * @param conn - The Knex database connection\n   * @param level - The transaction isolation level\n   * @param fn - The function to execute within the transaction\n   * @returns Promise that resolves when the transaction completes\n   *\n   * @example\n   * ```typescript\n   * await isolator.transact(knex, IsolationLevel.REPEATABLE_READ, async (trx) => {\n   *   // Use transaction with Objection models\n   *   await User.query(trx).insert({ name: 'Test' });\n   *   await Post.query(trx).where('userId', user.id).delete();\n   * });\n   * ```\n   */\n  async transact(\n    connection: Knex,\n    level: IsolationLevel,\n    fn: (trx: Knex.Transaction) => Promise<void>,\n  ): Promise<void> {\n    const isolationLevel = level.toLowerCase() as Lowercase<IsolationLevel>;\n\n    await connection.transaction(\n      async (trx) => {\n        await fn(trx);\n      },\n      {\n        isolationLevel,\n      },\n    );\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkCA,IAAa,qCAAb,cAAwD,kCAGtD;CACA,MAAM,QAAQA,MAAuC,CAAE;;;;;;;;;;;;;;;;;;;;CAoBvD,MAAM,SACJC,YACAC,OACAC,IACe;EACf,MAAM,iBAAiB,MAAM,aAAa;AAE1C,QAAM,WAAW,YACf,OAAO,QAAQ;AACb,SAAM,GAAG,IAAI;EACd,GACD,EACE,eACD,EACF;CACF;AACF"}
+{"version":3,"file":"VitestObjectionTransactionIsolator-_EhJKu_O.mjs","names":["conn: Knex<any, any[]>","connection: Knex","level: IsolationLevel","fn: (trx: Knex.Transaction) => Promise<void>"],"sources":["../src/VitestObjectionTransactionIsolator.ts"],"sourcesContent":["import type { Knex } from 'knex';\nimport {\n  type IsolationLevel,\n  VitestPostgresTransactionIsolator,\n} from './VitestTransactionIsolator';\n\n/**\n * Objection.js-specific implementation of the Vitest transaction isolator.\n * Provides automatic transaction rollback for test isolation using Objection.js and Knex transaction API.\n * Each test runs within a database transaction that is rolled back after completion,\n * ensuring a clean state between tests without the overhead of recreating data.\n *\n * @example\n * ```typescript\n * import { VitestObjectionTransactionIsolator } from '@geekmidas/testkit';\n * import { knex } from './database';\n * import { User } from './models';\n * import { test } from 'vitest';\n *\n * // Create isolator instance\n * const isolator = new VitestObjectionTransactionIsolator(test);\n *\n * // Use with wrapped test API\n * const isolatedTest = isolator.wrapVitestWithTransaction(knex);\n *\n * isolatedTest('should create user', async ({ trx }) => {\n *   const user = await User.query(trx)\n *     .insert({ name: 'Test User' });\n *\n *   expect(user).toBeDefined();\n *   // This data will be rolled back after the test\n * });\n * ```\n */\nexport class VitestObjectionTransactionIsolator extends VitestPostgresTransactionIsolator<\n  Knex,\n  Knex.Transaction\n> {\n  async destroy(conn: Knex<any, any[]>): Promise<void> {}\n  /**\n   * Creates a Knex transaction with the specified isolation level.\n   * Implements the abstract transact method from VitestPostgresTransactionIsolator.\n   * This transaction can be used with Objection.js models via Model.query(trx).\n   *\n   * @param conn - The Knex database connection\n   * @param level - The transaction isolation level\n   * @param fn - The function to execute within the transaction\n   * @returns Promise that resolves when the transaction completes\n   *\n   * @example\n   * ```typescript\n   * await isolator.transact(knex, IsolationLevel.REPEATABLE_READ, async (trx) => {\n   *   // Use transaction with Objection models\n   *   await User.query(trx).insert({ name: 'Test' });\n   *   await Post.query(trx).where('userId', user.id).delete();\n   * });\n   * ```\n   */\n  async transact(\n    connection: Knex,\n    level: IsolationLevel,\n    fn: (trx: Knex.Transaction) => Promise<void>,\n  ): Promise<void> {\n    const isolationLevel = level.toLowerCase() as Lowercase<IsolationLevel>;\n\n    await connection.transaction(\n      async (trx) => {\n        await fn(trx);\n      },\n      {\n        isolationLevel,\n      },\n    );\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkCA,IAAa,qCAAb,cAAwD,kCAGtD;CACA,MAAM,QAAQA,MAAuC,CAAE;;;;;;;;;;;;;;;;;;;;CAoBvD,MAAM,SACJC,YACAC,OACAC,IACe;EACf,MAAM,iBAAiB,MAAM,aAAa;AAE1C,QAAM,WAAW,YACf,OAAO,QAAQ;AACb,SAAM,GAAG,IAAI;EACd,GACD,EACE,eACD,EACF;CACF;AACF"}