@geekmidas/testkit 10.0.0-alpha.4 → 10.0.0-alpha.41

package/dist/ObjectionFactory.d.mts

@@ -1,4 +1,237 @@
-import "./faker-B6bmbGCM.mjs";
-import "./Factory-C15SSK8_.mjs";
-import { ObjectionFactory } from "./ObjectionFactory-Cf2WI4o_.mjs";
-export { ObjectionFactory };
+import { FakerFactory } from "./faker.mjs";
+import { ExtractSeedAttrs, FactorySeed } from "./Factory.mjs";
+import { Knex } from "knex";
+import { Model } from "objection";
+//#region src/ObjectionFactory.d.ts
+/**
+ * Factory implementation for Objection.js ORM, providing test data creation utilities.
+ * Extends the base Factory class with Objection.js-specific database operations.
+ *
+ * @template Builders - Record of builder functions for creating entities
+ * @template Seeds - Record of seed functions for complex test scenarios
+ *
+ * @example
+ * ```typescript
+ * // Define your models with Objection.js
+ * class User extends Model {
+ *   static tableName = 'users';
+ * }
+ *
+ * // Create builders
+ * const builders = {
+ *   user: ObjectionFactory.createBuilder(User, ({ attrs, faker }) => ({
+ *     id: faker.string.uuid(),
+ *     name: faker.person.fullName(),
+ *     email: faker.internet.email(),
+ *     ...attrs
+ *   })),
+ *   post: ObjectionFactory.createBuilder(Post, ({ attrs }) => ({
+ *     title: 'Test Post',
+ *     content: 'Test content',
+ *     ...attrs
+ *   })),
+ * };
+ *
+ * // Create factory instance
+ * const factory = new ObjectionFactory(builders, seeds, knex);
+ *
+ * // Use in tests
+ * const user = await factory.insert('user', { name: 'John Doe' });
+ * ```
+ */
+export declare class ObjectionFactory<Builders extends Record<string, any>, Seeds extends Record<string, any>> extends Factory<Builders, Seeds> {
+  private builders;
+  private seeds;
+  private db;
+  /**
+   * Creates a typed seed function with proper type inference.
+   * Inherits from the base Factory class implementation.
+   *
+   * @template Seed - The seed function type
+   * @param seedFn - The seed function to wrap (receives { attrs, factory, db } object)
+   * @returns The same seed function with proper typing
+   *
+   * @example
+   * ```typescript
+   * const seeds = {
+   *   userWithPosts: ObjectionFactory.createSeed(
+   *     async ({ attrs, factory }) => {
+   *       const user = await factory.insert('user', attrs);
+   *       await factory.insertMany(3, 'post', { userId: user.id });
+   *       return user;
+   *     },
+   *   ),
+   * };
+   * ```
+   */
+  static createSeed<Seed extends FactorySeed>(seedFn: Seed): Seed;
+  /**
+   * Creates a typed builder function for Objection.js models.
+   * This is a utility method that helps create builders with proper type inference.
+   *
+   * @template TModel - The Objection.js Model class type
+   * @template Attrs - The attributes type for the builder (defaults to Partial of model)
+   * @template Factory - The factory instance type
+   * @template Result - The result type (defaults to the model instance)
+   *
+   * @param ModelClass - The Objection.js Model class
+   * @param defaults - Optional function to provide default values (receives destructured context)
+   * @param autoInsert - Whether to automatically insert the record (default: true)
+   * @returns A builder function that creates and optionally inserts records
+   *
+   * @example
+   * ```typescript
+   * // Create a simple builder with defaults - destructure only what you need
+   * const userBuilder = ObjectionFactory.createBuilder(User,
+   *   ({ attrs, faker }) => ({
+   *     id: faker.string.uuid(),
+   *     name: faker.person.fullName(),
+   *     email: faker.internet.email(),
+   *     createdAt: new Date(),
+   *     ...attrs
+   *   })
+   * );
+   *
+   * // Only need faker? Just destructure that
+   * const leaveTypeBuilder = 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 }) => ({
+   *     street: '123 Main St',
+   *     city: 'Anytown',
+   *     ...attrs
+   *   }),
+   *   false // Don't auto-insert
+   * );
+   *
+   * // Use with relations
+   * const postBuilder = ObjectionFactory.createBuilder(Post,
+   *   async ({ attrs, factory, faker }) => ({
+   *     title: faker.lorem.sentence(),
+   *     content: faker.lorem.paragraphs(),
+   *     authorId: attrs.authorId || (await factory.insert('user')).id,
+   *     ...attrs
+   *   })
+   * );
+   * ```
+   */
+  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.
+   *
+   * @param builders - Record of builder functions for creating individual entities
+   * @param seeds - Record of seed functions for creating complex test scenarios
+   * @param db - Knex database connection instance
+   */
+  constructor(builders: Builders, seeds: Seeds, db: Knex);
+  /**
+   * Inserts a single record into the database using the specified builder.
+   * Uses Objection.js's insertGraph method to handle nested relations.
+   *
+   * @template K - The builder name (must be a key of Builders)
+   * @param builderName - The name of the builder to use
+   * @param attrs - Optional attributes to override builder defaults
+   * @returns A promise resolving to the inserted record with all relations
+   * @throws Error if the specified builder doesn't exist
+   *
+   * @example
+   * ```typescript
+   * // Insert with defaults
+   * const user = await factory.insert('user');
+   *
+   * // Insert with overrides
+   * const adminUser = await factory.insert('user', {
+   *   email: 'admin@example.com',
+   *   role: 'admin'
+   * });
+   *
+   * // Insert with nested relations
+   * const userWithProfile = await factory.insert('user', {
+   *   name: 'John Doe',
+   *   profile: {
+   *     bio: 'Software Developer',
+   *     avatar: 'avatar.jpg'
+   *   }
+   * });
+   * ```
+   */
+  insert<K extends keyof Builders>(builderName: K, attrs?: Parameters<Builders[K]>[0]): Promise<Awaited<ReturnType<Builders[K]>>>;
+  /**
+   * Inserts multiple records into the database using the specified builder.
+   * Supports both static attributes and dynamic attribute generation via a function.
+   *
+   * @param count - The number of records to insert
+   * @param builderName - The name of the builder to use
+   * @param attrs - Static attributes or a function that generates attributes for each record
+   * @returns A promise resolving to an array of inserted records
+   * @throws Error if the specified builder doesn't exist
+   *
+   * @example
+   * ```typescript
+   * // Insert multiple with same attributes
+   * const users = await factory.insertMany(5, 'user', { role: 'member' });
+   *
+   * // Insert multiple with dynamic attributes
+   * const posts = await factory.insertMany(10, 'post', (idx) => ({
+   *   title: `Post ${idx + 1}`,
+   *   content: `Content for post ${idx + 1}`,
+   *   publishedAt: new Date()
+   * }));
+   *
+   * // Create users with sequential emails
+   * const admins = await factory.insertMany(3, 'user', (idx) => ({
+   *   email: `admin${idx + 1}@example.com`,
+   *   role: 'admin'
+   * }));
+   * ```
+   */
+  insertMany<K extends keyof Builders>(count: number, builderName: K, attrs?: Parameters<Builders[K]>[0]): Promise<Awaited<ReturnType<Builders[K]>>[]>;
+  insertMany<K extends keyof Builders>(count: number, builderName: K, attrs: (idx: number, faker: FakerFactory) => Parameters<Builders[K]>[0]): Promise<Awaited<ReturnType<Builders[K]>>[]>;
+  /**
+   * Executes a seed function to create complex test scenarios with multiple related records.
+   * Seeds are useful for setting up complete test environments with realistic data relationships.
+   *
+   * @template K - The seed name (must be a key of Seeds)
+   * @param seedName - The name of the seed to execute
+   * @param attrs - Optional configuration attributes for the seed
+   * @returns The result of the seed function (typically the primary record created)
+   * @throws Error if the specified seed doesn't exist
+   *
+   * @example
+   * ```typescript
+   * // Execute a simple seed
+   * const user = await factory.seed('userWithProfile');
+   *
+   * // Execute a seed with configuration
+   * const author = await factory.seed('authorWithBooks', {
+   *   bookCount: 5,
+   *   includeReviews: true
+   * });
+   *
+   * // Use seed result in tests with Objection.js relations
+   * const company = await factory.seed('companyWithDepartments', {
+   *   departmentCount: 3,
+   *   employeesPerDepartment: 10
+   * });
+   *
+   * // Access eager loaded relations
+   * const companyWithRelations = await Company.query()
+   *   .findById(company.id)
+   *   .withGraphFetched('[departments.employees]');
+   * ```
+   */
+  seed<K extends keyof Seeds>(seedName: K, attrs?: ExtractSeedAttrs<Seeds[K]>): ReturnType<Seeds[K]>;
+}
+//#endregion
+//# sourceMappingURL=ObjectionFactory.d.mts.map

package/dist/ObjectionFactory.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ObjectionFactory.d.mts","names":[],"sources":["../src/ObjectionFactory.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAyCa,iBACZ,iBAAiB,qBACjB,cAAc,6BACL,QAAQ,UAAU;UA4JlB;UACA;UACA;;;;;;;;;;;;;;;;;;;;;;SAxIO,WAAW,aAAa,aAAa,QAAQ,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;SA4D7D,cACN,sBAAsB,OACtB,cAAc,QAAQ,aAAa,WAAW,QAAQ,aAAa,UACnE,eACA,SAAS,aAAa,SAEtB,YAAY,QACZ,YAAY;IACX,OAAO;IACP,SAAS;IACT,IAAI;IACJ,OAAO;QAEL,QAAQ,aAAa,WACrB,QAAQ,QAAQ,aAAa,WAChC,wBAEA,OAAO,OACP,SAAS,SACT,IAAI,MACJ,OAAO,iBACH,QAAQ;;;;;;;;EAoDb,YACS,UAAU,UACV,OAAO,OACP,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAoCP,OAAO,gBAAgB,UAC5B,aAAa,GACb,QAAQ,WAAW,SAAS,SAC1B,QAAQ,QAAQ,WAAW,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA+DjC,WAAW,gBAAgB,UAChC,eACA,aAAa,GACb,QAAQ,WAAW,SAAS,SAC1B,QAAQ,QAAQ,WAAW,SAAS;EACjC,WAAW,gBAAgB,UAChC,eACA,aAAa,GACb,QAAQ,aAAa,OAAO,iBAAiB,WAAW,SAAS,SAC/D,QAAQ,QAAQ,WAAW,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAgFvC,KAAK,gBAAgB,OACpB,UAAU,GACV,QAAQ,iBAAiB,MAAM,MAC7B,WAAW,MAAM"}

package/dist/ObjectionFactory.mjs

@@ -1,5 +1,265 @@
-import "./Factory-BFVnMMCC.mjs";
-import "./faker-BGKYFoCT.mjs";
-import { ObjectionFactory } from "./ObjectionFactory-QCJ7u0Ql.mjs";
+import { Factory } from "./Factory.mjs";
+import { faker } from "./faker.mjs";
+//#region src/ObjectionFactory.ts
+/**
+* Factory implementation for Objection.js ORM, providing test data creation utilities.
+* Extends the base Factory class with Objection.js-specific database operations.
+*
+* @template Builders - Record of builder functions for creating entities
+* @template Seeds - Record of seed functions for complex test scenarios
+*
+* @example
+* ```typescript
+* // Define your models with Objection.js
+* class User extends Model {
+*   static tableName = 'users';
+* }
+*
+* // Create builders
+* const builders = {
+*   user: ObjectionFactory.createBuilder(User, ({ attrs, faker }) => ({
+*     id: faker.string.uuid(),
+*     name: faker.person.fullName(),
+*     email: faker.internet.email(),
+*     ...attrs
+*   })),
+*   post: ObjectionFactory.createBuilder(Post, ({ attrs }) => ({
+*     title: 'Test Post',
+*     content: 'Test content',
+*     ...attrs
+*   })),
+* };
+*
+* // Create factory instance
+* const factory = new ObjectionFactory(builders, seeds, knex);
+*
+* // Use in tests
+* const user = await factory.insert('user', { name: 'John Doe' });
+* ```
+*/
+var ObjectionFactory = class extends Factory {
+	builders;
+	seeds;
+	db;
+	/**
+	* Creates a typed seed function with proper type inference.
+	* Inherits from the base Factory class implementation.
+	*
+	* @template Seed - The seed function type
+	* @param seedFn - The seed function to wrap (receives { attrs, factory, db } object)
+	* @returns The same seed function with proper typing
+	*
+	* @example
+	* ```typescript
+	* const seeds = {
+	*   userWithPosts: ObjectionFactory.createSeed(
+	*     async ({ attrs, factory }) => {
+	*       const user = await factory.insert('user', attrs);
+	*       await factory.insertMany(3, 'post', { userId: user.id });
+	*       return user;
+	*     },
+	*   ),
+	* };
+	* ```
+	*/
+	static createSeed(seedFn) {
+		return Factory.createSeed(seedFn);
+	}
+	/**
+	* Creates a typed builder function for Objection.js models.
+	* This is a utility method that helps create builders with proper type inference.
+	*
+	* @template TModel - The Objection.js Model class type
+	* @template Attrs - The attributes type for the builder (defaults to Partial of model)
+	* @template Factory - The factory instance type
+	* @template Result - The result type (defaults to the model instance)
+	*
+	* @param ModelClass - The Objection.js Model class
+	* @param defaults - Optional function to provide default values (receives destructured context)
+	* @param autoInsert - Whether to automatically insert the record (default: true)
+	* @returns A builder function that creates and optionally inserts records
+	*
+	* @example
+	* ```typescript
+	* // Create a simple builder with defaults - destructure only what you need
+	* const userBuilder = ObjectionFactory.createBuilder(User,
+	*   ({ attrs, faker }) => ({
+	*     id: faker.string.uuid(),
+	*     name: faker.person.fullName(),
+	*     email: faker.internet.email(),
+	*     createdAt: new Date(),
+	*     ...attrs
+	*   })
+	* );
+	*
+	* // Only need faker? Just destructure that
+	* const leaveTypeBuilder = 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 }) => ({
+	*     street: '123 Main St',
+	*     city: 'Anytown',
+	*     ...attrs
+	*   }),
+	*   false // Don't auto-insert
+	* );
+	*
+	* // Use with relations
+	* const postBuilder = ObjectionFactory.createBuilder(Post,
+	*   async ({ attrs, factory, faker }) => ({
+	*     title: faker.lorem.sentence(),
+	*     content: faker.lorem.paragraphs(),
+	*     authorId: attrs.authorId || (await factory.insert('user')).id,
+	*     ...attrs
+	*   })
+	* );
+	* ```
+	*/
+	static createBuilder(ModelClass, defaults, autoInsert) {
+		return async (attrs, factory, db, fakerInstance) => {
+			let data = { ...attrs };
+			if (defaults) data = {
+				...await defaults({
+					attrs,
+					factory,
+					db,
+					faker: fakerInstance
+				}),
+				...data
+			};
+			const model = ModelClass.fromJson(data);
+			if (autoInsert !== false) {
+				const insertData = Object.entries(model).reduce((acc, [key, value]) => {
+					if (value !== void 0 && key !== "id") acc[key] = value;
+					return acc;
+				}, {});
+				return await ModelClass.query(db).insert(insertData);
+			} else return model;
+		};
+	}
+	/**
+	* Creates a new ObjectionFactory instance.
+	*
+	* @param builders - Record of builder functions for creating individual entities
+	* @param seeds - Record of seed functions for creating complex test scenarios
+	* @param db - Knex database connection instance
+	*/
+	constructor(builders, seeds, db) {
+		super();
+		this.builders = builders;
+		this.seeds = seeds;
+		this.db = db;
+	}
+	/**
+	* Inserts a single record into the database using the specified builder.
+	* Uses Objection.js's insertGraph method to handle nested relations.
+	*
+	* @template K - The builder name (must be a key of Builders)
+	* @param builderName - The name of the builder to use
+	* @param attrs - Optional attributes to override builder defaults
+	* @returns A promise resolving to the inserted record with all relations
+	* @throws Error if the specified builder doesn't exist
+	*
+	* @example
+	* ```typescript
+	* // Insert with defaults
+	* const user = await factory.insert('user');
+	*
+	* // Insert with overrides
+	* const adminUser = await factory.insert('user', {
+	*   email: 'admin@example.com',
+	*   role: 'admin'
+	* });
+	*
+	* // Insert with nested relations
+	* const userWithProfile = await factory.insert('user', {
+	*   name: 'John Doe',
+	*   profile: {
+	*     bio: 'Software Developer',
+	*     avatar: 'avatar.jpg'
+	*   }
+	* });
+	* ```
+	*/
+	async insert(builderName, attrs) {
+		if (!(builderName in this.builders)) throw new Error(`Factory "${builderName}" does not exist. Make sure it is correct and registered in src/test/setup.ts`);
+		const result = await this.builders[builderName](attrs || {}, this, this.db, faker);
+		if (result && typeof result.$query === "function") {
+			const insertData = Object.entries(result).reduce((acc, [key, value]) => {
+				if (value !== void 0 && key !== "id") acc[key] = value;
+				return acc;
+			}, {});
+			return await result.constructor.query(this.db).insert(insertData);
+		}
+		return result;
+	}
+	async insertMany(count, builderName, attrs) {
+		if (!(builderName in this.builders)) throw new Error(`Builder "${builderName}" is not registered in this factory. Make sure it is correct and registered in src/test/setup.ts`);
+		const records = [];
+		for (let i = 0; i < count; i++) {
+			const newAttrs = typeof attrs === "function" ? await attrs(i, faker) : attrs;
+			records.push(this.builders[builderName](newAttrs, this, this.db, faker).then((record) => {
+				if (record && typeof record.$query === "function") {
+					const insertData = Object.entries(record).reduce((acc, [key, value]) => {
+						if (value !== void 0 && key !== "id") acc[key] = value;
+						return acc;
+					}, {});
+					return record.constructor.query(this.db).insert(insertData);
+				}
+				return record;
+			}));
+		}
+		return Promise.all(records);
+	}
+	/**
+	* Executes a seed function to create complex test scenarios with multiple related records.
+	* Seeds are useful for setting up complete test environments with realistic data relationships.
+	*
+	* @template K - The seed name (must be a key of Seeds)
+	* @param seedName - The name of the seed to execute
+	* @param attrs - Optional configuration attributes for the seed
+	* @returns The result of the seed function (typically the primary record created)
+	* @throws Error if the specified seed doesn't exist
+	*
+	* @example
+	* ```typescript
+	* // Execute a simple seed
+	* const user = await factory.seed('userWithProfile');
+	*
+	* // Execute a seed with configuration
+	* const author = await factory.seed('authorWithBooks', {
+	*   bookCount: 5,
+	*   includeReviews: true
+	* });
+	*
+	* // Use seed result in tests with Objection.js relations
+	* const company = await factory.seed('companyWithDepartments', {
+	*   departmentCount: 3,
+	*   employeesPerDepartment: 10
+	* });
+	*
+	* // Access eager loaded relations
+	* const companyWithRelations = await Company.query()
+	*   .findById(company.id)
+	*   .withGraphFetched('[departments.employees]');
+	* ```
+	*/
+	seed(seedName, attrs) {
+		if (!(seedName in this.seeds)) throw new Error(`Seed "${seedName}" is not registered in this factory. Make sure it is correct and registered in src/test/setup.ts`);
+		return this.seeds[seedName]({
+			attrs: attrs || {},
+			factory: this,
+			db: this.db
+		});
+	}
+};
+//#endregion
+export { ObjectionFactory };
 
-export { ObjectionFactory };
+//# sourceMappingURL=ObjectionFactory.mjs.map

package/dist/ObjectionFactory.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"ObjectionFactory.mjs","names":[],"sources":["../src/ObjectionFactory.ts"],"sourcesContent":["import type { Knex } from 'knex';\nimport type { Model } from 'objection';\nimport { type ExtractSeedAttrs, Factory, type FactorySeed } from './Factory';\nimport { type FakerFactory, faker } from './faker';\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\tBuilders extends Record<string, any>,\n\tSeeds extends Record<string, any>,\n> extends Factory<Builders, Seeds> {\n\t/**\n\t * Creates a typed seed function with proper type inference.\n\t * Inherits from the base Factory class implementation.\n\t *\n\t * @template Seed - The seed function type\n\t * @param seedFn - The seed function to wrap (receives { attrs, factory, db } object)\n\t * @returns The same seed function with proper typing\n\t *\n\t * @example\n\t * ```typescript\n\t * const seeds = {\n\t *   userWithPosts: ObjectionFactory.createSeed(\n\t *     async ({ attrs, factory }) => {\n\t *       const user = await factory.insert('user', attrs);\n\t *       await factory.insertMany(3, 'post', { userId: user.id });\n\t *       return user;\n\t *     },\n\t *   ),\n\t * };\n\t * ```\n\t */\n\tstatic override createSeed<Seed extends FactorySeed>(seedFn: Seed): Seed {\n\t\treturn Factory.createSeed(seedFn);\n\t}\n\n\t/**\n\t * Creates a typed builder function for Objection.js models.\n\t * This is a utility method that helps create builders with proper type inference.\n\t *\n\t * @template TModel - The Objection.js Model class type\n\t * @template Attrs - The attributes type for the builder (defaults to Partial of model)\n\t * @template Factory - The factory instance type\n\t * @template Result - The result type (defaults to the model instance)\n\t *\n\t * @param ModelClass - The Objection.js Model class\n\t * @param defaults - Optional function to provide default values (receives destructured context)\n\t * @param autoInsert - Whether to automatically insert the record (default: true)\n\t * @returns A builder function that creates and optionally inserts records\n\t *\n\t * @example\n\t * ```typescript\n\t * // Create a simple builder with defaults - destructure only what you need\n\t * const userBuilder = ObjectionFactory.createBuilder(User,\n\t *   ({ attrs, faker }) => ({\n\t *     id: faker.string.uuid(),\n\t *     name: faker.person.fullName(),\n\t *     email: faker.internet.email(),\n\t *     createdAt: new Date(),\n\t *     ...attrs\n\t *   })\n\t * );\n\t *\n\t * // Only need faker? Just destructure that\n\t * const leaveTypeBuilder = ObjectionFactory.createBuilder(LeaveType,\n\t *   ({ faker }) => ({\n\t *     name: faker.helpers.arrayElement(['Annual', 'Sick', 'Maternity']),\n\t *     code: faker.string.alpha({ length: 3, casing: 'upper' }),\n\t *   })\n\t * );\n\t *\n\t * // Create a builder that doesn't auto-insert (useful for nested inserts)\n\t * const addressBuilder = ObjectionFactory.createBuilder(Address,\n\t *   ({ attrs }) => ({\n\t *     street: '123 Main St',\n\t *     city: 'Anytown',\n\t *     ...attrs\n\t *   }),\n\t *   false // Don't auto-insert\n\t * );\n\t *\n\t * // Use with relations\n\t * const postBuilder = ObjectionFactory.createBuilder(Post,\n\t *   async ({ attrs, factory, faker }) => ({\n\t *     title: faker.lorem.sentence(),\n\t *     content: faker.lorem.paragraphs(),\n\t *     authorId: attrs.authorId || (await factory.insert('user')).id,\n\t *     ...attrs\n\t *   })\n\t * );\n\t * ```\n\t */\n\tstatic createBuilder<\n\t\tTModel extends typeof Model,\n\t\tAttrs extends Partial<InstanceType<TModel>> = Partial<InstanceType<TModel>>,\n\t\tFactory = any,\n\t\tResult = InstanceType<TModel>,\n\t>(\n\t\tModelClass: TModel,\n\t\tdefaults?: (context: {\n\t\t\tattrs: Attrs;\n\t\t\tfactory: Factory;\n\t\t\tdb: Knex;\n\t\t\tfaker: FakerFactory;\n\t\t}) =>\n\t\t\t| Partial<InstanceType<TModel>>\n\t\t\t| Promise<Partial<InstanceType<TModel>>>,\n\t\tautoInsert?: boolean,\n\t): (\n\t\tattrs: Attrs,\n\t\tfactory: Factory,\n\t\tdb: Knex,\n\t\tfaker: FakerFactory,\n\t) => Promise<Result> {\n\t\treturn async (\n\t\t\tattrs: Attrs,\n\t\t\tfactory: Factory,\n\t\t\tdb: Knex,\n\t\t\tfakerInstance: FakerFactory,\n\t\t) => {\n\t\t\t// Start with attributes\n\t\t\tlet data: Partial<InstanceType<TModel>> = { ...attrs };\n\n\t\t\t// Apply defaults\n\t\t\tif (defaults) {\n\t\t\t\tconst defaultValues = await defaults({\n\t\t\t\t\tattrs,\n\t\t\t\t\tfactory,\n\t\t\t\t\tdb,\n\t\t\t\t\tfaker: fakerInstance,\n\t\t\t\t});\n\t\t\t\tdata = { ...defaultValues, ...data };\n\t\t\t}\n\n\t\t\t// Create model instance\n\t\t\tconst model = ModelClass.fromJson(data) as InstanceType<TModel>;\n\n\t\t\t// Handle insertion based on autoInsert flag\n\t\t\tif (autoInsert !== false) {\n\t\t\t\t// Auto insert is enabled by default\n\t\t\t\t// Extract only defined values for insertion\n\t\t\t\tconst insertData = Object.entries(model).reduce((acc, [key, value]) => {\n\t\t\t\t\tif (value !== undefined && key !== 'id') {\n\t\t\t\t\t\tacc[key] = value;\n\t\t\t\t\t}\n\t\t\t\t\treturn acc;\n\t\t\t\t}, {} as any);\n\n\t\t\t\t// Use static query method to insert data directly\n\t\t\t\tconst result = await ModelClass.query(db).insert(insertData);\n\t\t\t\treturn result as Result;\n\t\t\t} else {\n\t\t\t\t// Return model for factory to handle insertion\n\t\t\t\treturn model as Result;\n\t\t\t}\n\t\t};\n\t}\n\n\t/**\n\t * Creates a new ObjectionFactory instance.\n\t *\n\t * @param builders - Record of builder functions for creating individual entities\n\t * @param seeds - Record of seed functions for creating complex test scenarios\n\t * @param db - Knex database connection instance\n\t */\n\tconstructor(\n\t\tprivate builders: Builders,\n\t\tprivate seeds: Seeds,\n\t\tprivate db: Knex,\n\t) {\n\t\tsuper();\n\t}\n\n\t/**\n\t * Inserts a single record into the database using the specified builder.\n\t * Uses Objection.js's insertGraph method to handle nested relations.\n\t *\n\t * @template K - The builder name (must be a key of Builders)\n\t * @param builderName - The name of the builder to use\n\t * @param attrs - Optional attributes to override builder defaults\n\t * @returns A promise resolving to the inserted record with all relations\n\t * @throws Error if the specified builder doesn't exist\n\t *\n\t * @example\n\t * ```typescript\n\t * // Insert with defaults\n\t * const user = await factory.insert('user');\n\t *\n\t * // Insert with overrides\n\t * const adminUser = await factory.insert('user', {\n\t *   email: 'admin@example.com',\n\t *   role: 'admin'\n\t * });\n\t *\n\t * // Insert with nested relations\n\t * const userWithProfile = await factory.insert('user', {\n\t *   name: 'John Doe',\n\t *   profile: {\n\t *     bio: 'Software Developer',\n\t *     avatar: 'avatar.jpg'\n\t *   }\n\t * });\n\t * ```\n\t */\n\tasync insert<K extends keyof Builders>(\n\t\tbuilderName: K,\n\t\tattrs?: Parameters<Builders[K]>[0],\n\t): Promise<Awaited<ReturnType<Builders[K]>>> {\n\t\tif (!(builderName in this.builders)) {\n\t\t\tthrow new Error(\n\t\t\t\t`Factory \"${\n\t\t\t\t\tbuilderName as string\n\t\t\t\t}\" does not exist. Make sure it is correct and registered in src/test/setup.ts`,\n\t\t\t);\n\t\t}\n\n\t\tconst result = await this.builders[builderName](\n\t\t\tattrs || {},\n\t\t\tthis,\n\t\t\tthis.db,\n\t\t\tfaker,\n\t\t);\n\n\t\t// If the builder returns a model instance, insert it\n\t\tif (result && typeof result.$query === 'function') {\n\t\t\t// Extract data from model, excluding undefined values and id\n\t\t\tconst insertData = Object.entries(result).reduce((acc, [key, value]) => {\n\t\t\t\tif (value !== undefined && key !== 'id') {\n\t\t\t\t\tacc[key] = value;\n\t\t\t\t}\n\t\t\t\treturn acc;\n\t\t\t}, {} as any);\n\n\t\t\t// Use the model's constructor to get the query builder\n\t\t\treturn await result.constructor.query(this.db).insert(insertData);\n\t\t}\n\n\t\t// Otherwise, assume the builder handled insertion itself\n\t\treturn result;\n\t}\n\t/**\n\t * Inserts multiple records into the database using the specified builder.\n\t * Supports both static attributes and dynamic attribute generation via a function.\n\t *\n\t * @param count - The number of records to insert\n\t * @param builderName - The name of the builder to use\n\t * @param attrs - Static attributes or a function that generates attributes for each record\n\t * @returns A promise resolving to an array of inserted records\n\t * @throws Error if the specified builder doesn't exist\n\t *\n\t * @example\n\t * ```typescript\n\t * // Insert multiple with same attributes\n\t * const users = await factory.insertMany(5, 'user', { role: 'member' });\n\t *\n\t * // Insert multiple with dynamic attributes\n\t * const posts = await factory.insertMany(10, 'post', (idx) => ({\n\t *   title: `Post ${idx + 1}`,\n\t *   content: `Content for post ${idx + 1}`,\n\t *   publishedAt: new Date()\n\t * }));\n\t *\n\t * // Create users with sequential emails\n\t * const admins = await factory.insertMany(3, 'user', (idx) => ({\n\t *   email: `admin${idx + 1}@example.com`,\n\t *   role: 'admin'\n\t * }));\n\t * ```\n\t */\n\t// Method overloads for better type inference\n\tasync insertMany<K extends keyof Builders>(\n\t\tcount: number,\n\t\tbuilderName: K,\n\t\tattrs?: Parameters<Builders[K]>[0],\n\t): Promise<Awaited<ReturnType<Builders[K]>>[]>;\n\tasync insertMany<K extends keyof Builders>(\n\t\tcount: number,\n\t\tbuilderName: K,\n\t\tattrs: (idx: number, faker: FakerFactory) => Parameters<Builders[K]>[0],\n\t): Promise<Awaited<ReturnType<Builders[K]>>[]>;\n\tasync insertMany<K extends keyof Builders>(\n\t\tcount: number,\n\t\tbuilderName: K,\n\t\tattrs?: any,\n\t): Promise<Awaited<ReturnType<Builders[K]>>[]> {\n\t\tif (!(builderName in this.builders)) {\n\t\t\tthrow new Error(\n\t\t\t\t`Builder \"${\n\t\t\t\t\tbuilderName as string\n\t\t\t\t}\" is not registered in this factory. Make sure it is correct and registered in src/test/setup.ts`,\n\t\t\t);\n\t\t}\n\n\t\tconst records: any[] = [];\n\t\tfor (let i = 0; i < count; i++) {\n\t\t\tconst newAttrs =\n\t\t\t\ttypeof attrs === 'function' ? await (attrs as any)(i, faker) : attrs;\n\n\t\t\trecords.push(\n\t\t\t\tthis.builders[builderName](newAttrs, this, this.db, faker).then(\n\t\t\t\t\t(record: any) => {\n\t\t\t\t\t\t// If the builder returns a model instance, insert it\n\t\t\t\t\t\tif (record && typeof record.$query === 'function') {\n\t\t\t\t\t\t\t// Extract data from model, excluding undefined values and id\n\t\t\t\t\t\t\tconst insertData = Object.entries(record).reduce(\n\t\t\t\t\t\t\t\t(acc, [key, value]) => {\n\t\t\t\t\t\t\t\t\tif (value !== undefined && key !== 'id') {\n\t\t\t\t\t\t\t\t\t\tacc[key] = value;\n\t\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t\t\treturn acc;\n\t\t\t\t\t\t\t\t},\n\t\t\t\t\t\t\t\t{} as any,\n\t\t\t\t\t\t\t);\n\n\t\t\t\t\t\t\t// Use the model's constructor to get the query builder\n\t\t\t\t\t\t\treturn record.constructor.query(this.db).insert(insertData);\n\t\t\t\t\t\t}\n\t\t\t\t\t\t// Otherwise, assume the builder handled insertion itself\n\t\t\t\t\t\treturn record;\n\t\t\t\t\t},\n\t\t\t\t),\n\t\t\t);\n\t\t}\n\n\t\treturn Promise.all(records);\n\t}\n\t/**\n\t * Executes a seed function to create complex test scenarios with multiple related records.\n\t * Seeds are useful for setting up complete test environments with realistic data relationships.\n\t *\n\t * @template K - The seed name (must be a key of Seeds)\n\t * @param seedName - The name of the seed to execute\n\t * @param attrs - Optional configuration attributes for the seed\n\t * @returns The result of the seed function (typically the primary record created)\n\t * @throws Error if the specified seed doesn't exist\n\t *\n\t * @example\n\t * ```typescript\n\t * // Execute a simple seed\n\t * const user = await factory.seed('userWithProfile');\n\t *\n\t * // Execute a seed with configuration\n\t * const author = await factory.seed('authorWithBooks', {\n\t *   bookCount: 5,\n\t *   includeReviews: true\n\t * });\n\t *\n\t * // Use seed result in tests with Objection.js relations\n\t * const company = await factory.seed('companyWithDepartments', {\n\t *   departmentCount: 3,\n\t *   employeesPerDepartment: 10\n\t * });\n\t *\n\t * // Access eager loaded relations\n\t * const companyWithRelations = await Company.query()\n\t *   .findById(company.id)\n\t *   .withGraphFetched('[departments.employees]');\n\t * ```\n\t */\n\tseed<K extends keyof Seeds>(\n\t\tseedName: K,\n\t\tattrs?: ExtractSeedAttrs<Seeds[K]>,\n\t): ReturnType<Seeds[K]> {\n\t\tif (!(seedName in this.seeds)) {\n\t\t\tthrow new Error(\n\t\t\t\t`Seed \"${\n\t\t\t\t\tseedName as string\n\t\t\t\t}\" is not registered in this factory. Make sure it is correct and registered in src/test/setup.ts`,\n\t\t\t);\n\t\t}\n\n\t\treturn this.seeds[seedName]({\n\t\t\tattrs: attrs || {},\n\t\t\tfactory: this,\n\t\t\tdb: this.db,\n\t\t});\n\t}\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAyCA,IAAa,mBAAb,cAGU,QAAyB;CA4JzB;CACA;CACA;;;;;;;;;;;;;;;;;;;;;;CAxIT,OAAgB,WAAqC,QAAoB;EACxE,OAAO,QAAQ,WAAW,MAAM;CACjC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA0DA,OAAO,cAMN,YACA,UAQA,YAMoB;EACpB,OAAO,OACN,OACA,SACA,IACA,kBACI;GAEJ,IAAI,OAAsC,EAAE,GAAG,MAAM;GAGrD,IAAI,UAOH,OAAO;IAAE,GAAG,MANgB,SAAS;KACpC;KACA;KACA;KACA,OAAO;IACR,CAAC;IAC0B,GAAG;GAAK;GAIpC,MAAM,QAAQ,WAAW,SAAS,IAAI;GAGtC,IAAI,eAAe,OAAO;IAGzB,MAAM,aAAa,OAAO,QAAQ,KAAK,CAAC,CAAC,QAAQ,KAAK,CAAC,KAAK,WAAW;KACtE,IAAI,UAAU,KAAA,KAAa,QAAQ,MAClC,IAAI,OAAO;KAEZ,OAAO;IACR,GAAG,CAAC,CAAQ;IAIZ,OAAO,MADc,WAAW,MAAM,EAAE,CAAC,CAAC,OAAO,UAAU;GAE5D,OAEC,OAAO;EAET;CACD;;;;;;;;CASA,YACC,UACA,OACA,IACC;EACD,MAAM;EAJE,KAAA,WAAA;EACA,KAAA,QAAA;EACA,KAAA,KAAA;CAGT;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAiCA,MAAM,OACL,aACA,OAC4C;EAC5C,IAAI,EAAE,eAAe,KAAK,WACzB,MAAM,IAAI,MACT,YACC,YACA,8EACF;EAGD,MAAM,SAAS,MAAM,KAAK,SAAS,YAAY,CAC9C,SAAS,CAAC,GACV,MACA,KAAK,IACL,KACD;EAGA,IAAI,UAAU,OAAO,OAAO,WAAW,YAAY;GAElD,MAAM,aAAa,OAAO,QAAQ,MAAM,CAAC,CAAC,QAAQ,KAAK,CAAC,KAAK,WAAW;IACvE,IAAI,UAAU,KAAA,KAAa,QAAQ,MAClC,IAAI,OAAO;IAEZ,OAAO;GACR,GAAG,CAAC,CAAQ;GAGZ,OAAO,MAAM,OAAO,YAAY,MAAM,KAAK,EAAE,CAAC,CAAC,OAAO,UAAU;EACjE;EAGA,OAAO;CACR;CAyCA,MAAM,WACL,OACA,aACA,OAC8C;EAC9C,IAAI,EAAE,eAAe,KAAK,WACzB,MAAM,IAAI,MACT,YACC,YACA,iGACF;EAGD,MAAM,UAAiB,CAAC;EACxB,KAAK,IAAI,IAAI,GAAG,IAAI,OAAO,KAAK;GAC/B,MAAM,WACL,OAAO,UAAU,aAAa,MAAO,MAAc,GAAG,KAAK,IAAI;GAEhE,QAAQ,KACP,KAAK,SAAS,YAAY,CAAC,UAAU,MAAM,KAAK,IAAI,KAAK,CAAC,CAAC,MACzD,WAAgB;IAEhB,IAAI,UAAU,OAAO,OAAO,WAAW,YAAY;KAElD,MAAM,aAAa,OAAO,QAAQ,MAAM,CAAC,CAAC,QACxC,KAAK,CAAC,KAAK,WAAW;MACtB,IAAI,UAAU,KAAA,KAAa,QAAQ,MAClC,IAAI,OAAO;MAEZ,OAAO;KACR,GACA,CAAC,CACF;KAGA,OAAO,OAAO,YAAY,MAAM,KAAK,EAAE,CAAC,CAAC,OAAO,UAAU;IAC3D;IAEA,OAAO;GACR,CACD,CACD;EACD;EAEA,OAAO,QAAQ,IAAI,OAAO;CAC3B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkCA,KACC,UACA,OACuB;EACvB,IAAI,EAAE,YAAY,KAAK,QACtB,MAAM,IAAI,MACT,SACC,SACA,iGACF;EAGD,OAAO,KAAK,MAAM,SAAS,CAAC;GAC3B,OAAO,SAAS,CAAC;GACjB,SAAS;GACT,IAAI,KAAK;EACV,CAAC;CACF;AACD"}

package/dist/PostgresKyselyMigrator.cjs

@@ -1,4 +1,95 @@
-require('./PostgresMigrator-M9jpzOvN.cjs');
-const require_PostgresKyselyMigrator = require('./PostgresKyselyMigrator-BGBxjnFv.cjs');
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_PostgresMigrator = require("./PostgresMigrator.cjs");
+let kysely_migration = require("kysely/migration");
+//#region src/PostgresKyselyMigrator.ts
+/**
+* Default logger instance for migration operations.
+*/
+const logger = console;
+/**
+* PostgreSQL migrator implementation for Kysely ORM.
+* Extends PostgresMigrator to provide Kysely-specific migration functionality.
+* Automatically creates test databases and applies migrations for testing environments.
+*
+* @example
+* ```typescript
+* import { FileMigrationProvider } from 'kysely';
+* import { PostgresKyselyMigrator } from '@geekmidas/testkit';
+*
+* // Create migration provider
+* const provider = new FileMigrationProvider({
+*   fs: require('fs'),
+*   path: require('path'),
+*   migrationFolder: path.join(__dirname, 'migrations')
+* });
+*
+* // Create Kysely instance
+* const db = new Kysely<Database>({
+*   dialect: new PostgresDialect({
+*     pool: new Pool({ connectionString: uri })
+*   })
+* });
+*
+* // Create and use migrator
+* const migrator = new PostgresKyselyMigrator({
+*   uri: 'postgresql://localhost:5432/test_db',
+*   db,
+*   provider
+* });
+*
+* const cleanup = await migrator.start();
+* // Run tests...
+* await cleanup();
+*
+* // With afterCreate hook to create per-app users
+* import { runInitScript } from '@geekmidas/testkit/postgres';
+*
+* const migrator = new PostgresKyselyMigrator({
+*   uri: 'postgresql://localhost:5432/test_db',
+*   db,
+*   provider,
+*   afterCreate: async (uri) => {
+*     await runInitScript('docker/postgres/init.sh', uri, env);
+*   },
+* });
+* ```
+*/
+var PostgresKyselyMigrator = class extends require_PostgresMigrator.PostgresMigrator {
+	options;
+	/**
+	* Creates a new PostgresKyselyMigrator instance.
+	*
+	* @param options - Configuration options
+	* @param options.uri - PostgreSQL connection URI
+	* @param options.db - Kysely database instance
+	* @param options.provider - Migration provider for locating migration files
+	* @param options.afterCreate - Optional hook called after database creation but before migrations
+	*/
+	constructor(options) {
+		super(options.uri, options.afterCreate);
+		this.options = options;
+	}
+	/**
+	* Executes Kysely migrations to the latest version.
+	* Implements the abstract migrate() method from PostgresMigrator.
+	*
+	* @throws Error if migrations fail to apply
+	* @returns Promise that resolves when all migrations are applied
+	*/
+	async migrate() {
+		const migrations = await new kysely_migration.Migrator({
+			db: this.options.db,
+			provider: this.options.provider
+		}).migrateToLatest();
+		if (migrations.error) {
+			logger.error(migrations.error, `Failed to apply migrations`);
+			throw migrations.error;
+		}
+		await this.options.db.destroy();
+		logger.log(`Applied ${migrations.results?.length} migrations successfully`);
+	}
+};
+//#endregion
+exports.PostgresKyselyMigrator = PostgresKyselyMigrator;
 
-exports.PostgresKyselyMigrator = require_PostgresKyselyMigrator.PostgresKyselyMigrator;
+//# sourceMappingURL=PostgresKyselyMigrator.cjs.map

package/dist/PostgresKyselyMigrator.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"PostgresKyselyMigrator.cjs","names":["PostgresMigrator","Migrator"],"sources":["../src/PostgresKyselyMigrator.ts"],"sourcesContent":["import type { Kysely } from 'kysely';\n// `Migrator` and the `MigrationProvider` type moved from the root barrel ('kysely')\n// to the 'kysely/migration' subpath in kysely 0.29+.\nimport { type MigrationProvider, Migrator } from 'kysely/migration';\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 * // With afterCreate hook to create per-app users\n * import { runInitScript } from '@geekmidas/testkit/postgres';\n *\n * const migrator = new PostgresKyselyMigrator({\n *   uri: 'postgresql://localhost:5432/test_db',\n *   db,\n *   provider,\n *   afterCreate: async (uri) => {\n *     await runInitScript('docker/postgres/init.sh', uri, env);\n *   },\n * });\n * ```\n */\nexport class PostgresKyselyMigrator extends PostgresMigrator {\n\t/**\n\t * Creates a new PostgresKyselyMigrator instance.\n\t *\n\t * @param options - Configuration options\n\t * @param options.uri - PostgreSQL connection URI\n\t * @param options.db - Kysely database instance\n\t * @param options.provider - Migration provider for locating migration files\n\t * @param options.afterCreate - Optional hook called after database creation but before migrations\n\t */\n\tconstructor(\n\t\tprivate options: {\n\t\t\turi: string;\n\t\t\tdb: Kysely<any>;\n\t\t\tprovider: MigrationProvider;\n\t\t\tafterCreate?: (uri: string) => Promise<void>;\n\t\t},\n\t) {\n\t\tsuper(options.uri, options.afterCreate);\n\t}\n\n\t/**\n\t * Executes Kysely migrations to the latest version.\n\t * Implements the abstract migrate() method from PostgresMigrator.\n\t *\n\t * @throws Error if migrations fail to apply\n\t * @returns Promise that resolves when all migrations are applied\n\t */\n\tasync migrate(): Promise<void> {\n\t\tconst migrator = new Migrator({\n\t\t\tdb: this.options.db,\n\t\t\tprovider: this.options.provider,\n\t\t});\n\t\tconst migrations = await migrator.migrateToLatest();\n\n\t\tif (migrations.error) {\n\t\t\tlogger.error(migrations.error, `Failed to apply migrations`);\n\t\t\tthrow migrations.error;\n\t\t}\n\n\t\tawait this.options.db.destroy();\n\n\t\tlogger.log(`Applied ${migrations.results?.length} migrations successfully`);\n\t}\n}\n"],"mappings":";;;;;;;AASA,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkDf,IAAa,yBAAb,cAA4CA,yBAAAA,iBAAiB;CAWnD;;;;;;;;;;CADT,YACC,SAMC;EACD,MAAM,QAAQ,KAAK,QAAQ,WAAW;EAP9B,KAAA,UAAA;CAQT;;;;;;;;CASA,MAAM,UAAyB;EAK9B,MAAM,aAAa,MAAM,IAJJC,iBAAAA,SAAS;GAC7B,IAAI,KAAK,QAAQ;GACjB,UAAU,KAAK,QAAQ;EACxB,CACgC,CAAC,CAAC,gBAAgB;EAElD,IAAI,WAAW,OAAO;GACrB,OAAO,MAAM,WAAW,OAAO,4BAA4B;GAC3D,MAAM,WAAW;EAClB;EAEA,MAAM,KAAK,QAAQ,GAAG,QAAQ;EAE9B,OAAO,IAAI,WAAW,WAAW,SAAS,OAAO,yBAAyB;CAC3E;AACD"}