@geekmidas/testkit 9.0.2 → 10.0.0-alpha.1

package/src/__tests__/Factory.spec.ts

@@ -1,178 +0,0 @@
-import { beforeEach, describe, expect, it } from 'vitest';
-import {
-	Factory,
-	type FactorySeed,
-	type MixedFactoryBuilder,
-} from '../Factory';
-
-// Create a concrete implementation for testing
-class TestFactory extends Factory<
-	{ testBuilder: (attrs: any) => any },
-	{ testSeed: (attrs: any, factory: any, db: any) => any }
-> {
-	async insert(_builderName: any, attrs?: any) {
-		return Promise.resolve({ id: 1, ...attrs });
-	}
-
-	async insertMany(count: number, builderName: any, attrs?: any) {
-		const results: any[] = [];
-		for (let i = 0; i < count; i++) {
-			const newAttrs = typeof attrs === 'function' ? attrs(i) : attrs;
-			results.push(await this.insert(builderName, newAttrs));
-		}
-		return results;
-	}
-
-	seed(_seedName: any, attrs?: any): any {
-		return Promise.resolve({ seedResult: true, ...attrs });
-	}
-}
-
-describe('Factory', () => {
-	describe('abstract class functionality', () => {
-		it('should be instantiable through concrete implementation', () => {
-			const factory = new TestFactory();
-			expect(factory).toBeInstanceOf(Factory);
-			expect(factory).toBeInstanceOf(TestFactory);
-		});
-
-		it('should have abstract methods defined', () => {
-			const factory = new TestFactory();
-			expect(typeof factory.insert).toBe('function');
-			expect(typeof factory.insertMany).toBe('function');
-			expect(typeof factory.seed).toBe('function');
-		});
-	});
-
-	describe('createSeed static method', () => {
-		it('should return the seed function unchanged', () => {
-			const seedFn = async ({
-				attrs,
-				factory,
-				db,
-			}: {
-				attrs: any;
-				factory: any;
-				db: any;
-			}) => {
-				return { id: 1, name: 'test' };
-			};
-
-			const result = Factory.createSeed(seedFn);
-
-			expect(result).toBe(seedFn);
-			expect(typeof result).toBe('function');
-		});
-
-		it('should work with different seed function signatures', () => {
-			const simpleSeed = async () => ({ simple: true });
-			const complexSeed = async ({
-				attrs,
-			}: {
-				attrs: { name: string };
-				factory: any;
-				db: any;
-			}) => {
-				return { name: attrs.name, created: true };
-			};
-
-			const result1 = Factory.createSeed(simpleSeed);
-			const result2 = Factory.createSeed(complexSeed);
-
-			expect(result1).toBe(simpleSeed);
-			expect(result2).toBe(complexSeed);
-		});
-	});
-
-	describe('concrete implementation behavior', () => {
-		let factory: TestFactory;
-
-		beforeEach(() => {
-			factory = new TestFactory();
-		});
-
-		it('should implement insert method', async () => {
-			const result = await factory.insert('testBuilder', { name: 'test' });
-			expect(result).toEqual({ id: 1, name: 'test' });
-		});
-
-		it('should implement insertMany method', async () => {
-			const results = await factory.insertMany(3, 'testBuilder', {
-				name: 'test',
-			});
-			expect(results).toHaveLength(3);
-			expect(results[0]).toEqual({ id: 1, name: 'test' });
-		});
-
-		it('should implement insertMany with function attributes', async () => {
-			const results = await factory.insertMany(2, 'testBuilder', (idx) => ({
-				name: `test${idx}`,
-			}));
-			expect(results).toHaveLength(2);
-			expect(results[0]).toEqual({ id: 1, name: 'test0' });
-			expect(results[1]).toEqual({ id: 1, name: 'test1' });
-		});
-
-		it('should implement seed method', async () => {
-			const result = await factory.seed('testSeed', { custom: 'value' });
-			expect(result).toEqual({ seedResult: true, custom: 'value' });
-		});
-	});
-
-	describe('type definitions', () => {
-		it('should properly type MixedFactoryBuilder', () => {
-			// Test that the type allows both sync and async returns
-			const syncBuilder: MixedFactoryBuilder = (_attrs, _factory, _db) => ({
-				sync: true,
-			});
-			const asyncBuilder: MixedFactoryBuilder = async (
-				_attrs,
-				_factory,
-				_db,
-			) => ({
-				async: true,
-			});
-
-			expect(typeof syncBuilder).toBe('function');
-			expect(typeof asyncBuilder).toBe('function');
-		});
-
-		it('should properly type FactorySeed', () => {
-			// Test that FactorySeed requires async return with object parameter
-			const seed: FactorySeed = async ({ attrs, factory, db }) => ({
-				seeded: true,
-			});
-
-			expect(typeof seed).toBe('function');
-		});
-	});
-});
-
-// Test the type exports
-describe('Factory types', () => {
-	it('should export MixedFactoryBuilder type', () => {
-		const builder: MixedFactoryBuilder<
-			{ name: string },
-			TestFactory,
-			{ id: number; name: string },
-			any
-		> = (attrs, _factory, _db) => {
-			return { id: 1, name: attrs.name };
-		};
-
-		expect(typeof builder).toBe('function');
-	});
-
-	it('should export FactorySeed type', () => {
-		const seed: FactorySeed<
-			{ count: number },
-			TestFactory,
-			{ created: number },
-			any
-		> = async ({ attrs }) => {
-			return { created: attrs.count };
-		};
-
-		expect(typeof seed).toBe('function');
-	});
-});

package/src/__tests__/KyselyFactory.spec.ts

@@ -1,458 +0,0 @@
-import pg from 'pg';
-import { describe, expect, it } from 'vitest';
-import { TEST_DATABASE_CONFIG } from '../../test/globalSetup';
-import { createTestTables, type TestDatabase } from '../../test/helpers';
-import { createKyselyDb } from '../helpers';
-import { KyselyFactory } from '../KyselyFactory';
-import { wrapVitestKyselyTransaction } from '../kysely';
-
-const db = () => createKyselyDb<TestDatabase>(TEST_DATABASE_CONFIG);
-const itWithTransaction = wrapVitestKyselyTransaction<TestDatabase>(it, {
-	connection: db,
-	setup: createTestTables,
-});
-
-const int8TypeId = 20;
-pg.types.setTypeParser(int8TypeId, (val) => {
-	return parseInt(val, 10);
-});
-describe('KyselyFactory', () => {
-	describe('KyselyFactory.insert', () => {
-		itWithTransaction(
-			'should insert a record with defaults',
-			async ({ trx }) => {
-				const userBuilder = KyselyFactory.createBuilder<TestDatabase, 'users'>(
-					'users',
-					async ({ attrs }) => ({
-						name: 'John Doe',
-						email: `user${Date.now()}@example.com`,
-						createdAt: new Date(),
-					}),
-				);
-
-				const builders = {
-					user: userBuilder,
-				};
-
-				const factory = new KyselyFactory<TestDatabase, typeof builders, {}>(
-					builders,
-					{},
-					trx,
-				);
-
-				const user = await factory.insert('user');
-
-				expect(user).toBeDefined();
-				expect(user.id).toBeDefined();
-				expect(user.name).toBe('John Doe');
-				expect(user.email).toContain('user');
-				expect(user.email).toContain('@example.com');
-				expect(user.createdAt).toBeInstanceOf(Date);
-			},
-		);
-
-		itWithTransaction(
-			'should override defaults with provided attributes',
-			async ({ trx }) => {
-				const userBuilder = KyselyFactory.createBuilder<TestDatabase, 'users'>(
-					'users',
-					async ({ attrs }) => ({
-						name: 'John Doe',
-						email: `user${Date.now()}@example.com`,
-						createdAt: new Date(),
-					}),
-				);
-
-				const builders = {
-					user: userBuilder,
-				};
-
-				const factory = new KyselyFactory<TestDatabase, typeof builders, {}>(
-					builders,
-					{},
-					trx,
-				);
-
-				const customEmail = 'custom@test.com';
-				const customName = 'Jane Smith';
-				const user = await factory.insert('user', {
-					email: customEmail,
-					name: customName,
-				});
-
-				expect(user.name).toBe(customName);
-				expect(user.email).toBe(customEmail);
-			},
-		);
-
-		itWithTransaction('should handle relations', async ({ trx }) => {
-			const userBuilder = KyselyFactory.createBuilder<TestDatabase, 'users'>(
-				'users',
-				async (_attrs) => ({
-					name: 'John Doe',
-					email: `user${Date.now()}@example.com`,
-					createdAt: new Date(),
-				}),
-			);
-
-			const postBuilder = KyselyFactory.createBuilder<TestDatabase, 'posts'>(
-				'posts',
-				async ({ attrs, factory }) => {
-					// Create a user if userId not provided
-					if (!attrs.userId) {
-						const user = await factory.insert('user');
-						return {
-							title: 'Default Post',
-							content: 'Default content',
-							userId: user.id,
-							createdAt: new Date(),
-						};
-					}
-					return {
-						title: 'Default Post',
-						content: 'Default content',
-						createdAt: new Date(),
-					};
-				},
-			);
-
-			const builders = {
-				user: userBuilder,
-				post: postBuilder,
-			};
-
-			const factory = new KyselyFactory<TestDatabase, typeof builders, {}>(
-				builders,
-				{},
-				trx,
-			);
-
-			const post = await factory.insert('post', {
-				title: 'Test Post',
-			});
-
-			expect(post).toBeDefined();
-			expect(post.title).toBe('Test Post');
-			expect(post.userId).toBeDefined();
-			expect(typeof post.userId).toBe('number');
-		});
-
-		itWithTransaction(
-			'should throw error for non-existent builder',
-			async ({ trx }) => {
-				const factory = new KyselyFactory<TestDatabase, any, {}>({}, {}, trx);
-
-				await expect(factory.insert('nonExistent' as any)).rejects.toThrow(
-					'Factory "nonExistent" does not exist',
-				);
-			},
-		);
-	});
-
-	describe('KyselyFactory.insertMany', () => {
-		itWithTransaction(
-			'should insert multiple records with same attributes',
-			async ({ trx }) => {
-				const userBuilder = KyselyFactory.createBuilder<TestDatabase, 'users'>(
-					'users',
-					async () => ({
-						name: 'John Doe',
-						email: `user${Date.now()}-${Math.random()}@example.com`,
-						createdAt: new Date(),
-					}),
-				);
-
-				const builders = {
-					user: userBuilder,
-				};
-
-				const factory = new KyselyFactory<TestDatabase, typeof builders, {}>(
-					builders,
-					{},
-					trx,
-				);
-
-				const users = await factory.insertMany(3, 'user');
-
-				expect(users).toHaveLength(3);
-				users.forEach((user, _index) => {
-					expect(user.id).toBeDefined();
-					expect(user.name).toBe('John Doe');
-					expect(user.email).toContain('@example.com');
-				});
-			},
-		);
-
-		itWithTransaction(
-			'should insert multiple records with dynamic attributes',
-			async ({ trx }) => {
-				const userBuilder = KyselyFactory.createBuilder<TestDatabase, 'users'>(
-					'users',
-					async () => ({
-						email: `user${Date.now()}-${Math.random()}@example.com`,
-						createdAt: new Date(),
-					}),
-				);
-
-				const builders = {
-					user: userBuilder,
-				};
-
-				const factory = new KyselyFactory<TestDatabase, typeof builders, {}>(
-					builders,
-					{},
-					trx,
-				);
-
-				const users = await factory.insertMany(3, 'user', (idx) => ({
-					name: `User ${idx}`,
-				}));
-
-				expect(users).toHaveLength(3);
-				users.forEach((user, index) => {
-					expect(user.name).toBe(`User ${index}`);
-				});
-			},
-		);
-
-		itWithTransaction(
-			'should throw error for non-existent builder',
-			async ({ trx }) => {
-				const factory = new KyselyFactory<TestDatabase, any, {}>({}, {}, trx);
-
-				await expect(
-					factory.insertMany(2, 'nonExistent' as any),
-				).rejects.toThrow('Builder "nonExistent" is not registered');
-			},
-		);
-	});
-
-	describe('KyselyFactory.createBuilder', () => {
-		itWithTransaction('should work with async defaults', async ({ trx }) => {
-			let counter = 0;
-			const userBuilder = KyselyFactory.createBuilder<TestDatabase, 'users'>(
-				'users',
-				async () => {
-					// Simulate async operation
-					await new Promise((resolve) => setTimeout(resolve, 10));
-					counter++;
-					return {
-						name: `Async User ${counter}`,
-						email: `user${counter}@example.com`,
-						createdAt: new Date(),
-					};
-				},
-			);
-
-			const builders = {
-				user: userBuilder,
-			};
-
-			const factory = new KyselyFactory<TestDatabase, typeof builders, {}>(
-				builders,
-				{},
-				trx,
-			);
-
-			const user1 = await factory.insert('user');
-			const user2 = await factory.insert('user');
-
-			expect(user1.name).toBe('Async User 1');
-			expect(user2.name).toBe('Async User 2');
-		});
-	});
-
-	describe('KyselyFactory.seed', () => {
-		itWithTransaction('should execute seed functions', async ({ trx }) => {
-			const userBuilder = KyselyFactory.createBuilder<TestDatabase, 'users'>(
-				'users',
-				async (_attrs) => ({
-					name: 'John Doe',
-					email: `user${Date.now()}@example.com`,
-					createdAt: new Date(),
-				}),
-			);
-
-			const builders = {
-				user: userBuilder,
-			};
-
-			const seeds = {
-				createAdminUser: KyselyFactory.createSeed(
-					async ({
-						attrs,
-						factory,
-					}: {
-						attrs: { name?: string };
-						factory: any;
-						db: any;
-					}) => {
-						return await factory.insert('user', {
-							name: attrs.name || 'Admin User',
-							email: 'admin@example.com',
-						});
-					},
-				),
-			};
-
-			const factory = new KyselyFactory<
-				TestDatabase,
-				typeof builders,
-				typeof seeds
-			>(builders, seeds, trx);
-
-			const adminUser = await factory.seed('createAdminUser');
-
-			expect(adminUser).toBeDefined();
-			expect(adminUser.name).toBe('Admin User');
-			expect(adminUser.email).toBe('admin@example.com');
-		});
-
-		itWithTransaction(
-			'should pass attributes to seed functions',
-			async ({ trx }) => {
-				const userBuilder = KyselyFactory.createBuilder<TestDatabase, 'users'>(
-					'users',
-					async ({ attrs }) => ({
-						name: 'John Doe',
-						email: `user${Date.now()}@example.com`,
-						createdAt: new Date(),
-					}),
-				);
-
-				const builders = {
-					user: userBuilder,
-				};
-
-				const seeds = {
-					createCustomUser: KyselyFactory.createSeed(
-						async ({
-							attrs,
-							factory,
-						}: {
-							attrs: { name: string; email: string };
-							factory: any;
-							db: any;
-						}) => {
-							return await factory.insert('user', attrs);
-						},
-					),
-				};
-
-				const factory = new KyselyFactory<
-					TestDatabase,
-					typeof builders,
-					typeof seeds
-				>(builders, seeds, trx);
-
-				const customUser = await factory.seed('createCustomUser', {
-					name: 'Custom User',
-					email: 'custom@test.com',
-				});
-
-				expect(customUser.name).toBe('Custom User');
-				expect(customUser.email).toBe('custom@test.com');
-			},
-		);
-
-		itWithTransaction(
-			'should throw error for non-existent seed',
-			async ({ trx }) => {
-				const factory = new KyselyFactory<TestDatabase, any, any>({}, {}, trx);
-
-				expect(() => factory.seed('nonExistent' as any)).toThrow(
-					'Seed "nonExistent" is not registered',
-				);
-			},
-		);
-	});
-
-	describe('Factory integration', () => {
-		itWithTransaction(
-			'should work with controlled transactions',
-			async ({ trx }) => {
-				const userBuilder = KyselyFactory.createBuilder<TestDatabase, 'users'>(
-					'users',
-					async ({ attrs }) => ({
-						name: 'John Doe',
-						email: `user${Date.now()}@example.com`,
-						createdAt: new Date(),
-					}),
-				);
-
-				const builders = {
-					user: userBuilder,
-				};
-
-				const factory = new KyselyFactory<TestDatabase, typeof builders, {}>(
-					builders,
-					{},
-					trx,
-				);
-
-				const user = await factory.insert('user');
-
-				// Verify the user exists in the transaction
-				const foundUser = await trx
-					.selectFrom('users')
-					.selectAll()
-					.where('id', '=', user.id)
-					.executeTakeFirst();
-
-				expect(foundUser).toBeDefined();
-				expect(foundUser?.id).toBe(user.id);
-			},
-		);
-
-		itWithTransaction(
-			'should work with factory passed to defaults',
-			async ({ trx }) => {
-				const userBuilder = KyselyFactory.createBuilder<TestDatabase, 'users'>(
-					'users',
-					async ({ attrs }) => ({
-						name: 'John Doe',
-						email: `user${Date.now()}@example.com`,
-						createdAt: new Date(),
-					}),
-				);
-
-				const postBuilder = KyselyFactory.createBuilder<TestDatabase, 'posts'>(
-					'posts',
-					async ({ factory }) => {
-						const user = await factory.insert('user');
-						return {
-							title: 'Default Post',
-							content: 'Default content',
-							userId: user.id,
-							createdAt: new Date(),
-						};
-					},
-				);
-
-				const builders = {
-					user: userBuilder,
-					post: postBuilder,
-				};
-
-				const factory = new KyselyFactory<TestDatabase, typeof builders, {}>(
-					builders,
-					{},
-					trx,
-				);
-
-				const post = await factory.insert('post');
-
-				expect(post.userId).toBeDefined();
-
-				// Verify the related user exists
-				const relatedUser = await trx
-					.selectFrom('users')
-					.selectAll()
-					.where('id', '=', post.userId)
-					.executeTakeFirst();
-
-				expect(relatedUser).toBeDefined();
-			},
-		);
-	});
-});