@geekmidas/testkit 0.0.5 → 0.0.7

package/dist/Factory-WMhTNZ9S.cjs

@@ -0,0 +1,56 @@
+
+//#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;
+  }
+});

package/dist/Factory-z2m01hMj.mjs

@@ -0,0 +1,50 @@
+//#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 };

package/dist/Factory.cjs

@@ -1,3 +1,3 @@
-const require_Factory = require('./Factory-DREHoms3.cjs');
+const require_Factory = require('./Factory-WMhTNZ9S.cjs');
 
 exports.Factory = require_Factory.Factory;

package/dist/Factory.mjs

@@ -1,3 +1,3 @@
-import { Factory } from "./Factory-DlzMkMzb.mjs";
+import { Factory } from "./Factory-z2m01hMj.mjs";
 
 export { Factory };

package/dist/KyselyFactory-Bdq1s1Go.cjs

@@ -0,0 +1,215 @@
+const require_Factory = require('./Factory-WMhTNZ9S.cjs');
+const require_faker = require('./faker-SMN4ira4.cjs');
+
+//#region src/KyselyFactory.ts
+/**
+* Factory implementation for Kysely ORM, providing test data creation utilities.
+* Extends the base Factory class with Kysely-specific database operations.
+*
+* @template DB - The database schema type
+* @template Builders - Record of builder functions for creating entities
+* @template Seeds - Record of seed functions for complex test scenarios
+*
+* @example
+* ```typescript
+* // Define your database schema
+* interface Database {
+*   users: UsersTable;
+*   posts: PostsTable;
+* }
+*
+* // Create builders
+* const builders = {
+*   user: KyselyFactory.createBuilder<Database, 'users'>('users', (attrs, factory, db, faker) => ({
+*     id: faker.string.uuid(),
+*     name: faker.person.fullName(),
+*     email: faker.internet.email(),
+*     ...attrs
+*   })),
+*   post: KyselyFactory.createBuilder<Database, 'posts'>('posts', (attrs) => ({
+*     title: 'Test Post',
+*     content: 'Test content',
+*     ...attrs
+*   }))
+* };
+*
+* // Create factory instance
+* const factory = new KyselyFactory(builders, seeds, db);
+*
+* // Use in tests
+* const user = await factory.insert('user', { name: 'John Doe' });
+* ```
+*/
+var KyselyFactory = class extends require_Factory.Factory {
+	/**
+	* 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
+	* @returns The same seed function with proper typing
+	*/
+	static createSeed(seedFn) {
+		return require_Factory.Factory.createSeed(seedFn);
+	}
+	/**
+	* Creates a new KyselyFactory instance.
+	*
+	* @param builders - Record of builder functions for creating individual entities
+	* @param seeds - Record of seed functions for creating complex test scenarios
+	* @param db - Kysely database instance or controlled transaction
+	*/
+	constructor(builders, seeds, db) {
+		super();
+		this.builders = builders;
+		this.seeds = seeds;
+		this.db = db;
+	}
+	/**
+	* Creates a typed builder function for a specific database table.
+	* This is a utility method that helps create builders with proper type inference for Kysely.
+	*
+	* @template DB - The database schema type
+	* @template TableName - The name of the table (must be a key of DB)
+	* @template Attrs - The attributes type for the builder (defaults to Partial<Insertable>)
+	* @template Factory - The factory instance type
+	* @template Result - The result type (defaults to Selectable of the table)
+	*
+	* @param table - The name of the database table
+	* @param item - Optional function to provide default values and transformations
+	* @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
+	* const userBuilder = KyselyFactory.createBuilder<DB, 'users'>('users',
+	*   (attrs, factory, db, faker) => ({
+	*     id: faker.string.uuid(),
+	*     name: faker.person.fullName(),
+	*     email: faker.internet.email(),
+	*     createdAt: new Date(),
+	*     ...attrs
+	*   })
+	* );
+	*
+	* // Create a builder that doesn't auto-insert (useful for nested inserts)
+	* const addressBuilder = KyselyFactory.createBuilder<DB, 'addresses'>('addresses',
+	*   (attrs) => ({
+	*     street: '123 Main St',
+	*     city: 'Anytown',
+	*     ...attrs
+	*   }),
+	*   false // Don't auto-insert
+	* );
+	* ```
+	*/
+	static createBuilder(table, item, autoInsert) {
+		return async (attrs, factory, db, faker$1) => {
+			let data = { ...attrs };
+			if (item) {
+				const defaults = await item(attrs, factory, db, faker$1);
+				data = {
+					...defaults,
+					...data
+				};
+			}
+			if (autoInsert !== false) {
+				const result = await db.insertInto(table).values(data).returningAll().executeTakeFirst();
+				if (!result) throw new Error(`Failed to insert into ${table}`);
+				return result;
+			} else return {
+				table,
+				data
+			};
+		};
+	}
+	/**
+	* Inserts a single record into the database using the specified builder.
+	* The builder function is responsible for generating the record data with defaults
+	* and the factory handles the actual database insertion.
+	*
+	* @template K - The builder name (must be a key of Builders)
+	* @param builderName - The name of the builder to use
+	* @param attrs - Optional attributes to override builder defaults
+	* @returns A promise resolving to the inserted record
+	* @throws Error if the specified builder doesn't exist
+	*
+	* @example
+	* ```typescript
+	* // Insert with defaults
+	* const user = await factory.insert('user');
+	*
+	* // Insert with overrides
+	* const adminUser = await factory.insert('user', {
+	*   email: 'admin@example.com',
+	*   role: 'admin'
+	* });
+	*
+	* // Use the inserted record
+	* const post = await factory.insert('post', {
+	*   userId: user.id,
+	*   title: 'My First Post'
+	* });
+	* ```
+	*/
+	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, require_faker.faker);
+		if (result && typeof result === "object" && "table" in result && "data" in result) {
+			const inserted = await this.db.insertInto(result.table).values(result.data).returningAll().executeTakeFirst();
+			return inserted;
+		}
+		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 promises = [];
+		for (let i = 0; i < count; i++) {
+			const newAttrs = typeof attrs === "function" ? attrs(i, require_faker.faker) : attrs;
+			promises.push(this.insert(builderName, newAttrs));
+		}
+		return Promise.all(promises);
+	}
+	/**
+	* Executes a seed function to create complex test scenarios with multiple related records.
+	* Seeds are useful for setting up complete test environments with realistic data relationships.
+	*
+	* @template K - The seed name (must be a key of Seeds)
+	* @param seedName - The name of the seed to execute
+	* @param attrs - Optional configuration attributes for the seed
+	* @returns The result of the seed function (typically the primary record created)
+	* @throws Error if the specified seed doesn't exist
+	*
+	* @example
+	* ```typescript
+	* // Execute a simple seed
+	* const user = await factory.seed('userWithProfile');
+	*
+	* // Execute a seed with configuration
+	* const author = await factory.seed('authorWithBooks', {
+	*   bookCount: 5,
+	*   includeReviews: true
+	* });
+	*
+	* // Use seed result in tests
+	* const company = await factory.seed('companyWithDepartments', {
+	*   departmentCount: 3,
+	*   employeesPerDepartment: 10
+	* });
+	* expect(company.departments).toHaveLength(3);
+	* ```
+	*/
+	seed(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 || {}, this, this.db);
+	}
+};
+
+//#endregion
+Object.defineProperty(exports, 'KyselyFactory', {
+  enumerable: true,
+  get: function () {
+    return KyselyFactory;
+  }
+});

package/dist/KyselyFactory-ELiHgHVv.mjs

@@ -0,0 +1,210 @@
+import { Factory } from "./Factory-z2m01hMj.mjs";
+import { faker } from "./faker-CxKkEeYi.mjs";
+
+//#region src/KyselyFactory.ts
+/**
+* Factory implementation for Kysely ORM, providing test data creation utilities.
+* Extends the base Factory class with Kysely-specific database operations.
+*
+* @template DB - The database schema type
+* @template Builders - Record of builder functions for creating entities
+* @template Seeds - Record of seed functions for complex test scenarios
+*
+* @example
+* ```typescript
+* // Define your database schema
+* interface Database {
+*   users: UsersTable;
+*   posts: PostsTable;
+* }
+*
+* // Create builders
+* const builders = {
+*   user: KyselyFactory.createBuilder<Database, 'users'>('users', (attrs, factory, db, faker) => ({
+*     id: faker.string.uuid(),
+*     name: faker.person.fullName(),
+*     email: faker.internet.email(),
+*     ...attrs
+*   })),
+*   post: KyselyFactory.createBuilder<Database, 'posts'>('posts', (attrs) => ({
+*     title: 'Test Post',
+*     content: 'Test content',
+*     ...attrs
+*   }))
+* };
+*
+* // Create factory instance
+* const factory = new KyselyFactory(builders, seeds, db);
+*
+* // Use in tests
+* const user = await factory.insert('user', { name: 'John Doe' });
+* ```
+*/
+var KyselyFactory = class extends Factory {
+	/**
+	* 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
+	* @returns The same seed function with proper typing
+	*/
+	static createSeed(seedFn) {
+		return Factory.createSeed(seedFn);
+	}
+	/**
+	* Creates a new KyselyFactory instance.
+	*
+	* @param builders - Record of builder functions for creating individual entities
+	* @param seeds - Record of seed functions for creating complex test scenarios
+	* @param db - Kysely database instance or controlled transaction
+	*/
+	constructor(builders, seeds, db) {
+		super();
+		this.builders = builders;
+		this.seeds = seeds;
+		this.db = db;
+	}
+	/**
+	* Creates a typed builder function for a specific database table.
+	* This is a utility method that helps create builders with proper type inference for Kysely.
+	*
+	* @template DB - The database schema type
+	* @template TableName - The name of the table (must be a key of DB)
+	* @template Attrs - The attributes type for the builder (defaults to Partial<Insertable>)
+	* @template Factory - The factory instance type
+	* @template Result - The result type (defaults to Selectable of the table)
+	*
+	* @param table - The name of the database table
+	* @param item - Optional function to provide default values and transformations
+	* @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
+	* const userBuilder = KyselyFactory.createBuilder<DB, 'users'>('users',
+	*   (attrs, factory, db, faker) => ({
+	*     id: faker.string.uuid(),
+	*     name: faker.person.fullName(),
+	*     email: faker.internet.email(),
+	*     createdAt: new Date(),
+	*     ...attrs
+	*   })
+	* );
+	*
+	* // Create a builder that doesn't auto-insert (useful for nested inserts)
+	* const addressBuilder = KyselyFactory.createBuilder<DB, 'addresses'>('addresses',
+	*   (attrs) => ({
+	*     street: '123 Main St',
+	*     city: 'Anytown',
+	*     ...attrs
+	*   }),
+	*   false // Don't auto-insert
+	* );
+	* ```
+	*/
+	static createBuilder(table, item, autoInsert) {
+		return async (attrs, factory, db, faker$1) => {
+			let data = { ...attrs };
+			if (item) {
+				const defaults = await item(attrs, factory, db, faker$1);
+				data = {
+					...defaults,
+					...data
+				};
+			}
+			if (autoInsert !== false) {
+				const result = await db.insertInto(table).values(data).returningAll().executeTakeFirst();
+				if (!result) throw new Error(`Failed to insert into ${table}`);
+				return result;
+			} else return {
+				table,
+				data
+			};
+		};
+	}
+	/**
+	* Inserts a single record into the database using the specified builder.
+	* The builder function is responsible for generating the record data with defaults
+	* and the factory handles the actual database insertion.
+	*
+	* @template K - The builder name (must be a key of Builders)
+	* @param builderName - The name of the builder to use
+	* @param attrs - Optional attributes to override builder defaults
+	* @returns A promise resolving to the inserted record
+	* @throws Error if the specified builder doesn't exist
+	*
+	* @example
+	* ```typescript
+	* // Insert with defaults
+	* const user = await factory.insert('user');
+	*
+	* // Insert with overrides
+	* const adminUser = await factory.insert('user', {
+	*   email: 'admin@example.com',
+	*   role: 'admin'
+	* });
+	*
+	* // Use the inserted record
+	* const post = await factory.insert('post', {
+	*   userId: user.id,
+	*   title: 'My First Post'
+	* });
+	* ```
+	*/
+	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 === "object" && "table" in result && "data" in result) {
+			const inserted = await this.db.insertInto(result.table).values(result.data).returningAll().executeTakeFirst();
+			return inserted;
+		}
+		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 promises = [];
+		for (let i = 0; i < count; i++) {
+			const newAttrs = typeof attrs === "function" ? attrs(i, faker) : attrs;
+			promises.push(this.insert(builderName, newAttrs));
+		}
+		return Promise.all(promises);
+	}
+	/**
+	* Executes a seed function to create complex test scenarios with multiple related records.
+	* Seeds are useful for setting up complete test environments with realistic data relationships.
+	*
+	* @template K - The seed name (must be a key of Seeds)
+	* @param seedName - The name of the seed to execute
+	* @param attrs - Optional configuration attributes for the seed
+	* @returns The result of the seed function (typically the primary record created)
+	* @throws Error if the specified seed doesn't exist
+	*
+	* @example
+	* ```typescript
+	* // Execute a simple seed
+	* const user = await factory.seed('userWithProfile');
+	*
+	* // Execute a seed with configuration
+	* const author = await factory.seed('authorWithBooks', {
+	*   bookCount: 5,
+	*   includeReviews: true
+	* });
+	*
+	* // Use seed result in tests
+	* const company = await factory.seed('companyWithDepartments', {
+	*   departmentCount: 3,
+	*   employeesPerDepartment: 10
+	* });
+	* expect(company.departments).toHaveLength(3);
+	* ```
+	*/
+	seed(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 || {}, this, this.db);
+	}
+};
+
+//#endregion
+export { KyselyFactory };

package/dist/KyselyFactory.cjs

@@ -1,5 +1,5 @@
-require('./Factory-DREHoms3.cjs');
-require('./faker-caz-8zt8.cjs');
-const require_KyselyFactory = require('./KyselyFactory-BX7Kv2uP.cjs');
+require('./Factory-WMhTNZ9S.cjs');
+require('./faker-SMN4ira4.cjs');
+const require_KyselyFactory = require('./KyselyFactory-Bdq1s1Go.cjs');
 
 exports.KyselyFactory = require_KyselyFactory.KyselyFactory;

package/dist/KyselyFactory.mjs

@@ -1,5 +1,5 @@
-import "./Factory-DlzMkMzb.mjs";
-import "./faker-BwaXA_RF.mjs";
-import { KyselyFactory } from "./KyselyFactory-pOMOFQWE.mjs";
+import "./Factory-z2m01hMj.mjs";
+import "./faker-CxKkEeYi.mjs";
+import { KyselyFactory } from "./KyselyFactory-ELiHgHVv.mjs";
 
 export { KyselyFactory };