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

package/dist/timer.d.cts

@@ -1,7 +1,4 @@
 //#region src/timer.d.ts
-declare function waitFor(ms: number): Promise<unknown>;
-//# sourceMappingURL=timer.d.ts.map
-
+export declare function waitFor(ms: number): Promise<unknown>;
 //#endregion
-export { waitFor };
 //# sourceMappingURL=timer.d.cts.map

package/dist/timer.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"timer.d.cts","names":[],"sources":["../src/timer.ts"],"sourcesContent":[],"mappings":";iBAAgB,OAAA,cAAkB;AAAlC"}
+{"version":3,"file":"timer.d.cts","names":[],"sources":["../src/timer.ts"],"mappings":";wBAAgB,QAAQ,aAAU"}

package/dist/timer.d.mts

@@ -1,7 +1,4 @@
 //#region src/timer.d.ts
-declare function waitFor(ms: number): Promise<unknown>;
-//# sourceMappingURL=timer.d.ts.map
-
+export declare function waitFor(ms: number): Promise<unknown>;
 //#endregion
-export { waitFor };
 //# sourceMappingURL=timer.d.mts.map

package/dist/timer.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"timer.d.mts","names":[],"sources":["../src/timer.ts"],"sourcesContent":[],"mappings":";iBAAgB,OAAA,cAAkB;AAAlC"}
+{"version":3,"file":"timer.d.mts","names":[],"sources":["../src/timer.ts"],"mappings":";wBAAgB,QAAQ,aAAU"}

package/dist/timer.mjs

@@ -2,7 +2,7 @@
 function waitFor(ms) {
 	return new Promise((resolve) => setTimeout(resolve, ms));
 }
-
 //#endregion
 export { waitFor };
+
 //# sourceMappingURL=timer.mjs.map

package/dist/timer.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"timer.mjs","names":["ms: number"],"sources":["../src/timer.ts"],"sourcesContent":["export function waitFor(ms: number) {\n\treturn new Promise((resolve) => setTimeout(resolve, ms));\n}\n"],"mappings":";AAAA,SAAgB,QAAQA,IAAY;AACnC,QAAO,IAAI,QAAQ,CAAC,YAAY,WAAW,SAAS,GAAG;AACvD"}
+{"version":3,"file":"timer.mjs","names":[],"sources":["../src/timer.ts"],"sourcesContent":["export function waitFor(ms: number) {\n\treturn new Promise((resolve) => setTimeout(resolve, ms));\n}\n"],"mappings":";AAAA,SAAgB,QAAQ,IAAY;CACnC,OAAO,IAAI,SAAS,YAAY,WAAW,SAAS,EAAE,CAAC;AACxD"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@geekmidas/testkit",
-  "version": "10.0.0-alpha.2",
+  "version": "10.0.0-alpha.20",
   "private": false,
   "type": "module",
   "exports": {
@@ -119,16 +119,18 @@
     "dist"
   ],
   "dependencies": {
-    "@faker-js/faker": "~9.9.0",
-    "@geekmidas/envkit": "^10.0.0-alpha.2",
-    "@geekmidas/logger": "^10.0.0-alpha.2",
-    "@geekmidas/services": "^10.0.0-alpha.2"
+    "@faker-js/faker": "~10.6.0",
+    "@geekmidas/envkit": "^10.0.0-alpha.20",
+    "@geekmidas/logger": "^10.0.0-alpha.20",
+    "@geekmidas/services": "^10.0.0-alpha.20"
   },
   "devDependencies": {
-    "@types/pg": "~8.15.4",
-    "@geekmidas/envkit": "^10.0.0-alpha.2",
-    "@geekmidas/logger": "^10.0.0-alpha.2",
-    "@geekmidas/services": "^10.0.0-alpha.2"
+    "@better-auth/test-utils": "~1.7.6",
+    "@types/pg": "~8.23.1",
+    "better-auth": "~1.7.6",
+    "@geekmidas/envkit": "^10.0.0-alpha.20",
+    "@geekmidas/logger": "^10.0.0-alpha.20",
+    "@geekmidas/services": "^10.0.0-alpha.20"
   },
   "repository": {
     "type": "git",
@@ -139,14 +141,14 @@
     "access": "public"
   },
   "peerDependencies": {
-    "kysely": "~0.29.4",
-    "pg": "~8.16.3",
-    "knex": "~3.1.0",
-    "objection": "~3.1.5",
+    "kysely": "~0.29.6",
+    "pg": ">=8.23.0",
+    "knex": ">=3.3.0",
+    "objection": ">=3.1.5",
     "db-errors": "~0.2.3",
-    "vitest": "~3.2.4",
-    "@types/aws-lambda": ">=8.10.92",
-    "better-auth": ">=1.3.34"
+    "vitest": "~5.0.2",
+    "@types/aws-lambda": ">=8.10.163",
+    "better-auth": ">=1.7.5"
   },
   "peerDependenciesMeta": {
     "kysely": {

package/dist/Factory-BFVnMMCC.mjs

@@ -1,51 +0,0 @@
-//#region src/Factory.ts
-/**
-* Abstract base class for database factories used in testing.
-* Provides a standardized interface for creating test data using builder and seed patterns.
-*
-* @template Builders - Record of builder functions for creating individual entities
-* @template Seeds - Record of seed functions for creating complex test scenarios
-*
-* @example
-* ```typescript
-* // Define builders for creating individual records
-* const builders = {
-*   user: (attrs) => ({ name: 'Test User', email: 'test@example.com', ...attrs }),
-*   post: (attrs) => ({ title: 'Test Post', content: 'Content', ...attrs })
-* };
-*
-* // Define seeds for complex scenarios
-* const seeds = {
-*   userWithPosts: async (attrs, factory) => {
-*     const user = await factory.insert('user', attrs);
-*     await factory.insertMany(3, 'post', { userId: user.id });
-*     return user;
-*   }
-* };
-* ```
-*/
-var Factory = class {
-	/**
-	* Creates a typed seed function with proper type inference.
-	* This is a utility method to help with TypeScript type checking when defining seeds.
-	*
-	* @template Seed - The seed function type
-	* @param seedFn - The seed function to wrap
-	* @returns The same seed function with proper typing
-	*
-	* @example
-	* ```typescript
-	* const userWithPostsSeed = Factory.createSeed(async ({ attrs, factory, db }) => {
-	*   const user = await factory.insert('user', attrs);
-	*   return user;
-	* });
-	* ```
-	*/
-	static createSeed(seedFn) {
-		return seedFn;
-	}
-};
-
-//#endregion
-export { Factory };
-//# sourceMappingURL=Factory-BFVnMMCC.mjs.map

package/dist/Factory-BFVnMMCC.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"Factory-BFVnMMCC.mjs","names":["seedFn: Seed"],"sources":["../src/Factory.ts"],"sourcesContent":["import type { FakerFactory } from './faker';\n\n/**\n * Abstract base class for database factories used in testing.\n * Provides a standardized interface for creating test data using builder and seed patterns.\n *\n * @template Builders - Record of builder functions for creating individual entities\n * @template Seeds - Record of seed functions for creating complex test scenarios\n *\n * @example\n * ```typescript\n * // Define builders for creating individual records\n * const builders = {\n *   user: (attrs) => ({ name: 'Test User', email: 'test@example.com', ...attrs }),\n *   post: (attrs) => ({ title: 'Test Post', content: 'Content', ...attrs })\n * };\n *\n * // Define seeds for complex scenarios\n * const seeds = {\n *   userWithPosts: async (attrs, factory) => {\n *     const user = await factory.insert('user', attrs);\n *     await factory.insertMany(3, 'post', { userId: user.id });\n *     return user;\n *   }\n * };\n * ```\n */\nexport abstract class Factory<\n\tBuilders extends Record<string, any>,\n\tSeeds extends Record<string, any>,\n> {\n\t/**\n\t * Creates a typed seed function with proper type inference.\n\t * This is a utility method to help with TypeScript type checking when defining seeds.\n\t *\n\t * @template Seed - The seed function type\n\t * @param seedFn - The seed function to wrap\n\t * @returns The same seed function with proper typing\n\t *\n\t * @example\n\t * ```typescript\n\t * const userWithPostsSeed = Factory.createSeed(async ({ attrs, factory, db }) => {\n\t *   const user = await factory.insert('user', attrs);\n\t *   return user;\n\t * });\n\t * ```\n\t */\n\tstatic createSeed<Seed extends FactorySeed>(seedFn: Seed): Seed {\n\t\treturn seedFn;\n\t}\n\t/**\n\t * Inserts an object into the database using a builder function.\n\t *\n\t * @param builderName - The name of the builder to use\n\t * @param attrs - The attributes to insert\n\t */\n\tabstract insert<K extends keyof Builders>(\n\t\tbuilderName: K,\n\t\tattrs?: Parameters<Builders[K]>[0],\n\t): Promise<Awaited<ReturnType<Builders[K]>>>;\n\n\t/**\n\t * Inserts multiple objects into the database\n\t *\n\t * @param count -  Number of objects to insert\n\t * @param builderName - The name of the builder to use\n\t * @param attrs - The attributes to insert\n\t */\n\tabstract insertMany<K extends keyof Builders>(\n\t\tcount: number,\n\t\tbuilderName: K,\n\t\tattrs?:\n\t\t\t| Parameters<Builders[K]>[0]\n\t\t\t| ((\n\t\t\t\t\tidx: number,\n\t\t\t\t\tfaker: FakerFactory,\n\t\t\t  ) => Promise<Parameters<Builders[K]>[0]>),\n\t): Promise<Awaited<ReturnType<Builders[K]>>[]>;\n\n\t/**\n\t * Seeds the database using a seed function.\n\t *\n\t * @param seedName - The name of the seed to use\n\t * @returns The result of the seed function\n\t * @param attrs - The attributes to pass to the seed function\n\t */\n\tabstract seed<K extends keyof Seeds>(\n\t\tseedName: K,\n\t\tattrs?: ExtractSeedAttrs<Seeds[K]>,\n\t): ReturnType<Seeds[K]>;\n}\n\n/**\n * Type definition for a factory builder function that can work with different database types.\n * Builders are responsible for creating individual database records with default values and relationships.\n *\n * @template Attrs - The attributes/input type for the builder\n * @template Factory - The factory instance type\n * @template Result - The type of object returned by the builder\n * @template DB - The database connection type (Kysely, Knex, etc.)\n *\n * @param attrs - Partial attributes to override defaults\n * @param factory - The factory instance for creating related records\n * @param db - The database connection\n * @returns The created record or a promise resolving to it\n *\n * @example\n * ```typescript\n * const userBuilder: MixedFactoryBuilder<UserAttrs, Factory, User, Kysely<DB>> =\n *   async (attrs, factory, db) => {\n *     return {\n *       id: faker.string.uuid(),\n *       name: faker.person.fullName(),\n *       email: faker.internet.email(),\n *       ...attrs\n *     };\n *   };\n * ```\n */\nexport type MixedFactoryBuilder<\n\tAttrs = any,\n\tFactory = any,\n\tResult = any,\n\tDB = any,\n> = (attrs: Attrs, factory: Factory, db: DB) => Result | Promise<Result>;\n\n/**\n * Type definition for a factory seed function used to create complex test scenarios.\n * Seeds typically create multiple related records to set up a complete test environment.\n *\n * @template Attrs - The attributes/input type for the seed\n * @template Factory - The factory instance type\n * @template Result - The type of object returned by the seed\n * @template DB - The database connection type (Kysely, Knex, etc.)\n *\n * @param context - Object containing attrs, factory, and db\n * @param context.attrs - Configuration attributes for the seed\n * @param context.factory - The factory instance for creating records\n * @param context.db - The database connection\n * @returns A promise resolving to the seed result\n *\n * @example\n * ```typescript\n * const userWithPostsSeed: FactorySeed<{ postCount?: number }, Factory, User, DB> =\n *   async ({ attrs, factory, db }) => {\n *     const user = await factory.insert('user', attrs);\n *     const postCount = attrs.postCount || 3;\n *\n *     for (let i = 0; i < postCount; i++) {\n *       await factory.insert('post', { userId: user.id });\n *     }\n *\n *     return user;\n *   };\n * ```\n */\nexport type FactorySeed<\n\tAttrs = any,\n\tFactory = any,\n\tResult = any,\n\tDB = any,\n> = (context: { attrs: Attrs; factory: Factory; db: DB }) => Promise<Result>;\n\n/**\n * Helper type to extract the Attrs type from a FactorySeed function.\n * Used internally by Factory implementations to correctly type the seed method parameters.\n */\nexport type ExtractSeedAttrs<T> = T extends (context: {\n\tattrs: infer A;\n\tfactory: any;\n\tdb: any;\n}) => any\n\t? A\n\t: never;\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;AA2BA,IAAsB,UAAtB,MAGE;;;;;;;;;;;;;;;;;CAiBD,OAAO,WAAqCA,QAAoB;AAC/D,SAAO;CACP;AAyCD"}

package/dist/Factory-BhjUOBWN.cjs

@@ -1,57 +0,0 @@
-
-//#region src/Factory.ts
-/**
-* Abstract base class for database factories used in testing.
-* Provides a standardized interface for creating test data using builder and seed patterns.
-*
-* @template Builders - Record of builder functions for creating individual entities
-* @template Seeds - Record of seed functions for creating complex test scenarios
-*
-* @example
-* ```typescript
-* // Define builders for creating individual records
-* const builders = {
-*   user: (attrs) => ({ name: 'Test User', email: 'test@example.com', ...attrs }),
-*   post: (attrs) => ({ title: 'Test Post', content: 'Content', ...attrs })
-* };
-*
-* // Define seeds for complex scenarios
-* const seeds = {
-*   userWithPosts: async (attrs, factory) => {
-*     const user = await factory.insert('user', attrs);
-*     await factory.insertMany(3, 'post', { userId: user.id });
-*     return user;
-*   }
-* };
-* ```
-*/
-var Factory = class {
-	/**
-	* Creates a typed seed function with proper type inference.
-	* This is a utility method to help with TypeScript type checking when defining seeds.
-	*
-	* @template Seed - The seed function type
-	* @param seedFn - The seed function to wrap
-	* @returns The same seed function with proper typing
-	*
-	* @example
-	* ```typescript
-	* const userWithPostsSeed = Factory.createSeed(async ({ attrs, factory, db }) => {
-	*   const user = await factory.insert('user', attrs);
-	*   return user;
-	* });
-	* ```
-	*/
-	static createSeed(seedFn) {
-		return seedFn;
-	}
-};
-
-//#endregion
-Object.defineProperty(exports, 'Factory', {
-  enumerable: true,
-  get: function () {
-    return Factory;
-  }
-});
-//# sourceMappingURL=Factory-BhjUOBWN.cjs.map

package/dist/Factory-BhjUOBWN.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"Factory-BhjUOBWN.cjs","names":["seedFn: Seed"],"sources":["../src/Factory.ts"],"sourcesContent":["import type { FakerFactory } from './faker';\n\n/**\n * Abstract base class for database factories used in testing.\n * Provides a standardized interface for creating test data using builder and seed patterns.\n *\n * @template Builders - Record of builder functions for creating individual entities\n * @template Seeds - Record of seed functions for creating complex test scenarios\n *\n * @example\n * ```typescript\n * // Define builders for creating individual records\n * const builders = {\n *   user: (attrs) => ({ name: 'Test User', email: 'test@example.com', ...attrs }),\n *   post: (attrs) => ({ title: 'Test Post', content: 'Content', ...attrs })\n * };\n *\n * // Define seeds for complex scenarios\n * const seeds = {\n *   userWithPosts: async (attrs, factory) => {\n *     const user = await factory.insert('user', attrs);\n *     await factory.insertMany(3, 'post', { userId: user.id });\n *     return user;\n *   }\n * };\n * ```\n */\nexport abstract class Factory<\n\tBuilders extends Record<string, any>,\n\tSeeds extends Record<string, any>,\n> {\n\t/**\n\t * Creates a typed seed function with proper type inference.\n\t * This is a utility method to help with TypeScript type checking when defining seeds.\n\t *\n\t * @template Seed - The seed function type\n\t * @param seedFn - The seed function to wrap\n\t * @returns The same seed function with proper typing\n\t *\n\t * @example\n\t * ```typescript\n\t * const userWithPostsSeed = Factory.createSeed(async ({ attrs, factory, db }) => {\n\t *   const user = await factory.insert('user', attrs);\n\t *   return user;\n\t * });\n\t * ```\n\t */\n\tstatic createSeed<Seed extends FactorySeed>(seedFn: Seed): Seed {\n\t\treturn seedFn;\n\t}\n\t/**\n\t * Inserts an object into the database using a builder function.\n\t *\n\t * @param builderName - The name of the builder to use\n\t * @param attrs - The attributes to insert\n\t */\n\tabstract insert<K extends keyof Builders>(\n\t\tbuilderName: K,\n\t\tattrs?: Parameters<Builders[K]>[0],\n\t): Promise<Awaited<ReturnType<Builders[K]>>>;\n\n\t/**\n\t * Inserts multiple objects into the database\n\t *\n\t * @param count -  Number of objects to insert\n\t * @param builderName - The name of the builder to use\n\t * @param attrs - The attributes to insert\n\t */\n\tabstract insertMany<K extends keyof Builders>(\n\t\tcount: number,\n\t\tbuilderName: K,\n\t\tattrs?:\n\t\t\t| Parameters<Builders[K]>[0]\n\t\t\t| ((\n\t\t\t\t\tidx: number,\n\t\t\t\t\tfaker: FakerFactory,\n\t\t\t  ) => Promise<Parameters<Builders[K]>[0]>),\n\t): Promise<Awaited<ReturnType<Builders[K]>>[]>;\n\n\t/**\n\t * Seeds the database using a seed function.\n\t *\n\t * @param seedName - The name of the seed to use\n\t * @returns The result of the seed function\n\t * @param attrs - The attributes to pass to the seed function\n\t */\n\tabstract seed<K extends keyof Seeds>(\n\t\tseedName: K,\n\t\tattrs?: ExtractSeedAttrs<Seeds[K]>,\n\t): ReturnType<Seeds[K]>;\n}\n\n/**\n * Type definition for a factory builder function that can work with different database types.\n * Builders are responsible for creating individual database records with default values and relationships.\n *\n * @template Attrs - The attributes/input type for the builder\n * @template Factory - The factory instance type\n * @template Result - The type of object returned by the builder\n * @template DB - The database connection type (Kysely, Knex, etc.)\n *\n * @param attrs - Partial attributes to override defaults\n * @param factory - The factory instance for creating related records\n * @param db - The database connection\n * @returns The created record or a promise resolving to it\n *\n * @example\n * ```typescript\n * const userBuilder: MixedFactoryBuilder<UserAttrs, Factory, User, Kysely<DB>> =\n *   async (attrs, factory, db) => {\n *     return {\n *       id: faker.string.uuid(),\n *       name: faker.person.fullName(),\n *       email: faker.internet.email(),\n *       ...attrs\n *     };\n *   };\n * ```\n */\nexport type MixedFactoryBuilder<\n\tAttrs = any,\n\tFactory = any,\n\tResult = any,\n\tDB = any,\n> = (attrs: Attrs, factory: Factory, db: DB) => Result | Promise<Result>;\n\n/**\n * Type definition for a factory seed function used to create complex test scenarios.\n * Seeds typically create multiple related records to set up a complete test environment.\n *\n * @template Attrs - The attributes/input type for the seed\n * @template Factory - The factory instance type\n * @template Result - The type of object returned by the seed\n * @template DB - The database connection type (Kysely, Knex, etc.)\n *\n * @param context - Object containing attrs, factory, and db\n * @param context.attrs - Configuration attributes for the seed\n * @param context.factory - The factory instance for creating records\n * @param context.db - The database connection\n * @returns A promise resolving to the seed result\n *\n * @example\n * ```typescript\n * const userWithPostsSeed: FactorySeed<{ postCount?: number }, Factory, User, DB> =\n *   async ({ attrs, factory, db }) => {\n *     const user = await factory.insert('user', attrs);\n *     const postCount = attrs.postCount || 3;\n *\n *     for (let i = 0; i < postCount; i++) {\n *       await factory.insert('post', { userId: user.id });\n *     }\n *\n *     return user;\n *   };\n * ```\n */\nexport type FactorySeed<\n\tAttrs = any,\n\tFactory = any,\n\tResult = any,\n\tDB = any,\n> = (context: { attrs: Attrs; factory: Factory; db: DB }) => Promise<Result>;\n\n/**\n * Helper type to extract the Attrs type from a FactorySeed function.\n * Used internally by Factory implementations to correctly type the seed method parameters.\n */\nexport type ExtractSeedAttrs<T> = T extends (context: {\n\tattrs: infer A;\n\tfactory: any;\n\tdb: any;\n}) => any\n\t? A\n\t: never;\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;AA2BA,IAAsB,UAAtB,MAGE;;;;;;;;;;;;;;;;;CAiBD,OAAO,WAAqCA,QAAoB;AAC/D,SAAO;CACP;AAyCD"}

package/dist/Factory-CVR3GdkW.d.mts

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

package/dist/Factory-CVR3GdkW.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"Factory-CVR3GdkW.d.mts","names":[],"sources":["../src/Factory.ts"],"sourcesContent":[],"mappings":";;;;;;AA2BA;;;;;;;;;;;;;;;;;;;;;;;AAiD6B,uBAjDP,OAiDO,CAAA,iBAhDX,MAgDW,CAAA,MAAA,EAAA,GAAA,CAAA,EAAA,cA/Cd,MA+Cc,CAAA,MAAA,EAAA,GAAA,CAAA,CAAA,CAAA;EAAQ;;;;;;;;;;;;;;;;EAavB,OAAA,UAAA,CAAA,aA1CkB,WA0ClB,CAAA,CAAA,MAAA,EA1CuC,IA0CvC,CAAA,EA1C8C,IA0C9C;EA8BF;;;;;;EAK0C,SAAW,MAAA,CAAA,UAAA,MApEhC,QAoEgC,CAAA,CAAA,WAAA,EAnElD,CAmEkD,EAAA,KAAA,CAAA,EAlEvD,UAkEuD,CAlE5C,QAkE4C,CAlEnC,CAkEmC,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,EAjE7D,OAiE6D,CAjErD,OAiEqD,CAjE7C,UAiE6C,CAjElC,QAiEkC,CAjEzB,CAiEyB,CAAA,CAAA,CAAA,CAAA;EAAM;AAAP;AAgChE;;;;;EAKsD,SAAe,UAAA,CAAA,UAAA,MA7FhC,QA6FgC,CAAA,CAAA,KAAA,EAAA,MAAA,EAAA,WAAA,EA3FtD,CA2FsD,EAAA,KAAA,CAAA,EAzFhE,UAyFgE,CAzFrD,QAyFqD,CAzF5C,CAyF4C,CAAA,CAAA,CAAA,CAAA,CAAA,GAAA,CAAA,CAAA,GAAA,EAAA,MAAA,EAAA,KAAA,EAtFzD,YAsFyD,EAAA,GArF3D,OAqF2D,CArFnD,UAqFmD,CArFxC,QAqFwC,CArF/B,CAqF+B,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,EApFjE,OAoFiE,CApFzD,OAoFyD,CApFjD,UAoFiD,CApFtC,QAoFsC,CApF7B,CAoF6B,CAAA,CAAA,CAAA,EAAA,CAAA;EAAM;AAAP;AAMpE;;;;AAKI;gCAtF2B,iBACnB,WACF,iBAAiB,MAAM,MAC7B,WAAW,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KA8BT,kFAKA,gBAAgB,aAAa,OAAO,SAAS,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAgCrD;SAKW;WAAgB;MAAa;MAAS,QAAQ;;;;;KAMzD,sBAAsB;;;;aAK/B"}

package/dist/Factory-Cwzho3c8.d.cts

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

package/dist/Factory-Cwzho3c8.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"Factory-Cwzho3c8.d.cts","names":[],"sources":["../src/Factory.ts"],"sourcesContent":[],"mappings":";;;;;;AA2BA;;;;;;;;;;;;;;;;;;;;;;;AAiD6B,uBAjDP,OAiDO,CAAA,iBAhDX,MAgDW,CAAA,MAAA,EAAA,GAAA,CAAA,EAAA,cA/Cd,MA+Cc,CAAA,MAAA,EAAA,GAAA,CAAA,CAAA,CAAA;EAAQ;;;;;;;;;;;;;;;;EAavB,OAAA,UAAA,CAAA,aA1CkB,WA0ClB,CAAA,CAAA,MAAA,EA1CuC,IA0CvC,CAAA,EA1C8C,IA0C9C;EA8BF;;;;;;EAK0C,SAAW,MAAA,CAAA,UAAA,MApEhC,QAoEgC,CAAA,CAAA,WAAA,EAnElD,CAmEkD,EAAA,KAAA,CAAA,EAlEvD,UAkEuD,CAlE5C,QAkE4C,CAlEnC,CAkEmC,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,EAjE7D,OAiE6D,CAjErD,OAiEqD,CAjE7C,UAiE6C,CAjElC,QAiEkC,CAjEzB,CAiEyB,CAAA,CAAA,CAAA,CAAA;EAAM;AAAP;AAgChE;;;;;EAKsD,SAAe,UAAA,CAAA,UAAA,MA7FhC,QA6FgC,CAAA,CAAA,KAAA,EAAA,MAAA,EAAA,WAAA,EA3FtD,CA2FsD,EAAA,KAAA,CAAA,EAzFhE,UAyFgE,CAzFrD,QAyFqD,CAzF5C,CAyF4C,CAAA,CAAA,CAAA,CAAA,CAAA,GAAA,CAAA,CAAA,GAAA,EAAA,MAAA,EAAA,KAAA,EAtFzD,YAsFyD,EAAA,GArF3D,OAqF2D,CArFnD,UAqFmD,CArFxC,QAqFwC,CArF/B,CAqF+B,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,EApFjE,OAoFiE,CApFzD,OAoFyD,CApFjD,UAoFiD,CApFtC,QAoFsC,CApF7B,CAoF6B,CAAA,CAAA,CAAA,EAAA,CAAA;EAAM;AAAP;AAMpE;;;;AAKI;gCAtF2B,iBACnB,WACF,iBAAiB,MAAM,MAC7B,WAAW,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KA8BT,kFAKA,gBAAgB,aAAa,OAAO,SAAS,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAgCrD;SAKW;WAAgB;MAAa;MAAS,QAAQ;;;;;KAMzD,sBAAsB;;;;aAK/B"}