@geekmidas/testkit 0.0.15 → 0.0.16

package/dist/__tests__/Factory.spec.cjs

@@ -1,139 +0,0 @@
-const require_chunk = require('../chunk-CUT6urMc.cjs');
-const require_Factory = require('../Factory-WMhTNZ9S.cjs');
-const vitest = require_chunk.__toESM(require("vitest"));
-
-//#region src/__tests__/Factory.spec.ts
-var TestFactory = class extends require_Factory.Factory {
-	async insert(builderName, attrs) {
-		return Promise.resolve({
-			id: 1,
-			...attrs
-		});
-	}
-	async insertMany(count, builderName, attrs) {
-		const results = [];
-		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, attrs) {
-		return Promise.resolve({
-			seedResult: true,
-			...attrs
-		});
-	}
-};
-(0, vitest.describe)("Factory", () => {
-	(0, vitest.describe)("abstract class functionality", () => {
-		(0, vitest.it)("should be instantiable through concrete implementation", () => {
-			const factory = new TestFactory();
-			(0, vitest.expect)(factory).toBeInstanceOf(require_Factory.Factory);
-			(0, vitest.expect)(factory).toBeInstanceOf(TestFactory);
-		});
-		(0, vitest.it)("should have abstract methods defined", () => {
-			const factory = new TestFactory();
-			(0, vitest.expect)(typeof factory.insert).toBe("function");
-			(0, vitest.expect)(typeof factory.insertMany).toBe("function");
-			(0, vitest.expect)(typeof factory.seed).toBe("function");
-		});
-	});
-	(0, vitest.describe)("createSeed static method", () => {
-		(0, vitest.it)("should return the seed function unchanged", () => {
-			const seedFn = async (attrs, factory, db) => {
-				return {
-					id: 1,
-					name: "test"
-				};
-			};
-			const result = require_Factory.Factory.createSeed(seedFn);
-			(0, vitest.expect)(result).toBe(seedFn);
-			(0, vitest.expect)(typeof result).toBe("function");
-		});
-		(0, vitest.it)("should work with different seed function signatures", () => {
-			const simpleSeed = () => Promise.resolve({ simple: true });
-			const complexSeed = async (attrs, factory, db) => {
-				return {
-					name: attrs.name,
-					created: true
-				};
-			};
-			const result1 = require_Factory.Factory.createSeed(simpleSeed);
-			const result2 = require_Factory.Factory.createSeed(complexSeed);
-			(0, vitest.expect)(result1).toBe(simpleSeed);
-			(0, vitest.expect)(result2).toBe(complexSeed);
-		});
-	});
-	(0, vitest.describe)("concrete implementation behavior", () => {
-		let factory;
-		(0, vitest.beforeEach)(() => {
-			factory = new TestFactory();
-		});
-		(0, vitest.it)("should implement insert method", async () => {
-			const result = await factory.insert("testBuilder", { name: "test" });
-			(0, vitest.expect)(result).toEqual({
-				id: 1,
-				name: "test"
-			});
-		});
-		(0, vitest.it)("should implement insertMany method", async () => {
-			const results = await factory.insertMany(3, "testBuilder", { name: "test" });
-			(0, vitest.expect)(results).toHaveLength(3);
-			(0, vitest.expect)(results[0]).toEqual({
-				id: 1,
-				name: "test"
-			});
-		});
-		(0, vitest.it)("should implement insertMany with function attributes", async () => {
-			const results = await factory.insertMany(2, "testBuilder", (idx) => ({ name: `test${idx}` }));
-			(0, vitest.expect)(results).toHaveLength(2);
-			(0, vitest.expect)(results[0]).toEqual({
-				id: 1,
-				name: "test0"
-			});
-			(0, vitest.expect)(results[1]).toEqual({
-				id: 1,
-				name: "test1"
-			});
-		});
-		(0, vitest.it)("should implement seed method", async () => {
-			const result = await factory.seed("testSeed", { custom: "value" });
-			(0, vitest.expect)(result).toEqual({
-				seedResult: true,
-				custom: "value"
-			});
-		});
-	});
-	(0, vitest.describe)("type definitions", () => {
-		(0, vitest.it)("should properly type MixedFactoryBuilder", () => {
-			const syncBuilder = (attrs, factory, db) => ({ sync: true });
-			const asyncBuilder = async (attrs, factory, db) => ({ async: true });
-			(0, vitest.expect)(typeof syncBuilder).toBe("function");
-			(0, vitest.expect)(typeof asyncBuilder).toBe("function");
-		});
-		(0, vitest.it)("should properly type FactorySeed", () => {
-			const seed = async (attrs, factory, db) => ({ seeded: true });
-			(0, vitest.expect)(typeof seed).toBe("function");
-		});
-	});
-});
-(0, vitest.describe)("Factory types", () => {
-	(0, vitest.it)("should export MixedFactoryBuilder type", () => {
-		const builder = (attrs, factory, db) => {
-			return {
-				id: 1,
-				name: attrs.name
-			};
-		};
-		(0, vitest.expect)(typeof builder).toBe("function");
-	});
-	(0, vitest.it)("should export FactorySeed type", () => {
-		const seed = async (attrs, factory, db) => {
-			return { created: attrs.count };
-		};
-		(0, vitest.expect)(typeof seed).toBe("function");
-	});
-});
-
-//#endregion

package/dist/__tests__/Factory.spec.d.cts

@@ -1 +0,0 @@
-export { };

package/dist/__tests__/Factory.spec.d.mts

@@ -1 +0,0 @@
-export { };

package/dist/__tests__/Factory.spec.mjs

@@ -1,138 +0,0 @@
-import { Factory } from "../Factory-z2m01hMj.mjs";
-import { beforeEach, describe, expect, it } from "vitest";
-
-//#region src/__tests__/Factory.spec.ts
-var TestFactory = class extends Factory {
-	async insert(builderName, attrs) {
-		return Promise.resolve({
-			id: 1,
-			...attrs
-		});
-	}
-	async insertMany(count, builderName, attrs) {
-		const results = [];
-		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, attrs) {
-		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) => {
-				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 = () => Promise.resolve({ simple: true });
-			const complexSeed = async (attrs, factory, db) => {
-				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;
-		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", () => {
-			const syncBuilder = (attrs, factory, db) => ({ sync: true });
-			const asyncBuilder = async (attrs, factory, db) => ({ async: true });
-			expect(typeof syncBuilder).toBe("function");
-			expect(typeof asyncBuilder).toBe("function");
-		});
-		it("should properly type FactorySeed", () => {
-			const seed = async (attrs, factory, db) => ({ seeded: true });
-			expect(typeof seed).toBe("function");
-		});
-	});
-});
-describe("Factory types", () => {
-	it("should export MixedFactoryBuilder type", () => {
-		const builder = (attrs, factory, db) => {
-			return {
-				id: 1,
-				name: attrs.name
-			};
-		};
-		expect(typeof builder).toBe("function");
-	});
-	it("should export FactorySeed type", () => {
-		const seed = async (attrs, factory, db) => {
-			return { created: attrs.count };
-		};
-		expect(typeof seed).toBe("function");
-	});
-});
-
-//#endregion

package/dist/__tests__/KyselyFactory.spec.cjs

@@ -1,235 +0,0 @@
-const require_chunk = require('../chunk-CUT6urMc.cjs');
-require('../Factory-WMhTNZ9S.cjs');
-require('../faker-B14IEMIN.cjs');
-const require_KyselyFactory = require('../KyselyFactory-Cf0o2YxO.cjs');
-require('../PostgresMigrator-DFcNdCvD.cjs');
-require('../PostgresKyselyMigrator-CfytARcA.cjs');
-require('../VitestTransactionIsolator-BQ5FpLtC.cjs');
-require('../VitestKyselyTransactionIsolator-Cst3vFjb.cjs');
-const require_helpers = require('../helpers-nEUtQ7eo.cjs');
-const require_kysely = require('../kysely-VU3MwvMD.cjs');
-const require_helpers$1 = require('../helpers-Bf0nXhbu.cjs');
-const pg = require_chunk.__toESM(require("pg"));
-const vitest = require_chunk.__toESM(require("vitest"));
-
-//#region src/__tests__/KyselyFactory.spec.ts
-const db = () => require_helpers.createKyselyDb(require_helpers$1.TEST_DATABASE_CONFIG);
-const itWithTransaction = require_kysely.wrapVitestKyselyTransaction(vitest.it, db, require_helpers$1.createTestTables);
-const int8TypeId = 20;
-pg.default.types.setTypeParser(int8TypeId, (val) => {
-	return parseInt(val, 10);
-});
-(0, vitest.describe)("KyselyFactory", () => {
-	(0, vitest.describe)("KyselyFactory.insert", () => {
-		itWithTransaction("should insert a record with defaults", async ({ trx }) => {
-			const userBuilder = require_KyselyFactory.KyselyFactory.createBuilder("users", async (attrs) => ({
-				name: "John Doe",
-				email: `user${Date.now()}@example.com`,
-				createdAt: /* @__PURE__ */ new Date()
-			}));
-			const builders = { user: userBuilder };
-			const factory = new require_KyselyFactory.KyselyFactory(builders, {}, trx);
-			const user = await factory.insert("user");
-			(0, vitest.expect)(user).toBeDefined();
-			(0, vitest.expect)(user.id).toBeDefined();
-			(0, vitest.expect)(user.name).toBe("John Doe");
-			(0, vitest.expect)(user.email).toContain("user");
-			(0, vitest.expect)(user.email).toContain("@example.com");
-			(0, vitest.expect)(user.createdAt).toBeInstanceOf(Date);
-		});
-		itWithTransaction("should override defaults with provided attributes", async ({ trx }) => {
-			const userBuilder = require_KyselyFactory.KyselyFactory.createBuilder("users", async (attrs) => ({
-				name: "John Doe",
-				email: `user${Date.now()}@example.com`,
-				createdAt: /* @__PURE__ */ new Date()
-			}));
-			const builders = { user: userBuilder };
-			const factory = new require_KyselyFactory.KyselyFactory(builders, {}, trx);
-			const customEmail = "custom@test.com";
-			const customName = "Jane Smith";
-			const user = await factory.insert("user", {
-				email: customEmail,
-				name: customName
-			});
-			(0, vitest.expect)(user.name).toBe(customName);
-			(0, vitest.expect)(user.email).toBe(customEmail);
-		});
-		itWithTransaction("should handle relations", async ({ trx }) => {
-			const userBuilder = require_KyselyFactory.KyselyFactory.createBuilder("users", async (attrs) => ({
-				name: "John Doe",
-				email: `user${Date.now()}@example.com`,
-				createdAt: /* @__PURE__ */ new Date()
-			}));
-			const postBuilder = require_KyselyFactory.KyselyFactory.createBuilder("posts", async (attrs, factory$1) => {
-				if (!attrs.userId) {
-					const user = await factory$1.insert("user");
-					return {
-						title: "Default Post",
-						content: "Default content",
-						userId: user.id,
-						createdAt: /* @__PURE__ */ new Date()
-					};
-				}
-				return {
-					title: "Default Post",
-					content: "Default content",
-					createdAt: /* @__PURE__ */ new Date()
-				};
-			});
-			const builders = {
-				user: userBuilder,
-				post: postBuilder
-			};
-			const factory = new require_KyselyFactory.KyselyFactory(builders, {}, trx);
-			const post = await factory.insert("post", { title: "Test Post" });
-			(0, vitest.expect)(post).toBeDefined();
-			(0, vitest.expect)(post.title).toBe("Test Post");
-			(0, vitest.expect)(post.userId).toBeDefined();
-			(0, vitest.expect)(typeof post.userId).toBe("number");
-		});
-		itWithTransaction("should throw error for non-existent builder", async ({ trx }) => {
-			const factory = new require_KyselyFactory.KyselyFactory({}, {}, trx);
-			await (0, vitest.expect)(factory.insert("nonExistent")).rejects.toThrow("Factory \"nonExistent\" does not exist");
-		});
-	});
-	(0, vitest.describe)("KyselyFactory.insertMany", () => {
-		itWithTransaction("should insert multiple records with same attributes", async ({ trx }) => {
-			const userBuilder = require_KyselyFactory.KyselyFactory.createBuilder("users", async (attrs) => ({
-				name: "John Doe",
-				email: `user${Date.now()}-${Math.random()}@example.com`,
-				createdAt: /* @__PURE__ */ new Date()
-			}));
-			const builders = { user: userBuilder };
-			const factory = new require_KyselyFactory.KyselyFactory(builders, {}, trx);
-			const users = await factory.insertMany(3, "user");
-			(0, vitest.expect)(users).toHaveLength(3);
-			users.forEach((user, index) => {
-				(0, vitest.expect)(user.id).toBeDefined();
-				(0, vitest.expect)(user.name).toBe("John Doe");
-				(0, vitest.expect)(user.email).toContain("@example.com");
-			});
-		});
-		itWithTransaction("should insert multiple records with dynamic attributes", async ({ trx }) => {
-			const userBuilder = require_KyselyFactory.KyselyFactory.createBuilder("users", async (attrs) => ({
-				email: `user${Date.now()}-${Math.random()}@example.com`,
-				createdAt: /* @__PURE__ */ new Date()
-			}));
-			const builders = { user: userBuilder };
-			const factory = new require_KyselyFactory.KyselyFactory(builders, {}, trx);
-			const users = await factory.insertMany(3, "user", (idx) => ({ name: `User ${idx}` }));
-			(0, vitest.expect)(users).toHaveLength(3);
-			users.forEach((user, index) => {
-				(0, vitest.expect)(user.name).toBe(`User ${index}`);
-			});
-		});
-		itWithTransaction("should throw error for non-existent builder", async ({ trx }) => {
-			const factory = new require_KyselyFactory.KyselyFactory({}, {}, trx);
-			await (0, vitest.expect)(factory.insertMany(2, "nonExistent")).rejects.toThrow("Builder \"nonExistent\" is not registered");
-		});
-	});
-	(0, vitest.describe)("KyselyFactory.createBuilder", () => {
-		itWithTransaction("should work with async defaults", async ({ trx }) => {
-			let counter = 0;
-			const userBuilder = require_KyselyFactory.KyselyFactory.createBuilder("users", async (attrs) => {
-				await new Promise((resolve) => setTimeout(resolve, 10));
-				counter++;
-				return {
-					name: `Async User ${counter}`,
-					email: `user${counter}@example.com`,
-					createdAt: /* @__PURE__ */ new Date()
-				};
-			});
-			const builders = { user: userBuilder };
-			const factory = new require_KyselyFactory.KyselyFactory(builders, {}, trx);
-			const user1 = await factory.insert("user");
-			const user2 = await factory.insert("user");
-			(0, vitest.expect)(user1.name).toBe("Async User 1");
-			(0, vitest.expect)(user2.name).toBe("Async User 2");
-		});
-	});
-	(0, vitest.describe)("KyselyFactory.seed", () => {
-		itWithTransaction("should execute seed functions", async ({ trx }) => {
-			const userBuilder = require_KyselyFactory.KyselyFactory.createBuilder("users", async (attrs) => ({
-				name: "John Doe",
-				email: `user${Date.now()}@example.com`,
-				createdAt: /* @__PURE__ */ new Date()
-			}));
-			const builders = { user: userBuilder };
-			const seeds = { createAdminUser: require_KyselyFactory.KyselyFactory.createSeed(async (attrs, factory$1, db$1) => {
-				return await factory$1.insert("user", {
-					name: attrs.name || "Admin User",
-					email: "admin@example.com"
-				});
-			}) };
-			const factory = new require_KyselyFactory.KyselyFactory(builders, seeds, trx);
-			const adminUser = await factory.seed("createAdminUser");
-			(0, vitest.expect)(adminUser).toBeDefined();
-			(0, vitest.expect)(adminUser.name).toBe("Admin User");
-			(0, vitest.expect)(adminUser.email).toBe("admin@example.com");
-		});
-		itWithTransaction("should pass attributes to seed functions", async ({ trx }) => {
-			const userBuilder = require_KyselyFactory.KyselyFactory.createBuilder("users", async (attrs) => ({
-				name: "John Doe",
-				email: `user${Date.now()}@example.com`,
-				createdAt: /* @__PURE__ */ new Date()
-			}));
-			const builders = { user: userBuilder };
-			const seeds = { createCustomUser: require_KyselyFactory.KyselyFactory.createSeed(async (attrs, factory$1, db$1) => {
-				return await factory$1.insert("user", attrs);
-			}) };
-			const factory = new require_KyselyFactory.KyselyFactory(builders, seeds, trx);
-			const customUser = await factory.seed("createCustomUser", {
-				name: "Custom User",
-				email: "custom@test.com"
-			});
-			(0, vitest.expect)(customUser.name).toBe("Custom User");
-			(0, vitest.expect)(customUser.email).toBe("custom@test.com");
-		});
-		itWithTransaction("should throw error for non-existent seed", async ({ trx }) => {
-			const factory = new require_KyselyFactory.KyselyFactory({}, {}, trx);
-			(0, vitest.expect)(() => factory.seed("nonExistent")).toThrow("Seed \"nonExistent\" is not registered");
-		});
-	});
-	(0, vitest.describe)("Factory integration", () => {
-		itWithTransaction("should work with controlled transactions", async ({ trx }) => {
-			const userBuilder = require_KyselyFactory.KyselyFactory.createBuilder("users", async (attrs) => ({
-				name: "John Doe",
-				email: `user${Date.now()}@example.com`,
-				createdAt: /* @__PURE__ */ new Date()
-			}));
-			const builders = { user: userBuilder };
-			const factory = new require_KyselyFactory.KyselyFactory(builders, {}, trx);
-			const user = await factory.insert("user");
-			const foundUser = await trx.selectFrom("users").selectAll().where("id", "=", user.id).executeTakeFirst();
-			(0, vitest.expect)(foundUser).toBeDefined();
-			(0, vitest.expect)(foundUser?.id).toBe(user.id);
-		});
-		itWithTransaction("should work with factory passed to defaults", async ({ trx }) => {
-			const userBuilder = require_KyselyFactory.KyselyFactory.createBuilder("users", async (attrs) => ({
-				name: "John Doe",
-				email: `user${Date.now()}@example.com`,
-				createdAt: /* @__PURE__ */ new Date()
-			}));
-			const postBuilder = require_KyselyFactory.KyselyFactory.createBuilder("posts", async (attrs, factory$1) => {
-				const user = await factory$1.insert("user");
-				return {
-					title: "Default Post",
-					content: "Default content",
-					userId: user.id,
-					createdAt: /* @__PURE__ */ new Date()
-				};
-			});
-			const builders = {
-				user: userBuilder,
-				post: postBuilder
-			};
-			const factory = new require_KyselyFactory.KyselyFactory(builders, {}, trx);
-			const post = await factory.insert("post");
-			(0, vitest.expect)(post.userId).toBeDefined();
-			const relatedUser = await trx.selectFrom("users").selectAll().where("id", "=", post.userId).executeTakeFirst();
-			(0, vitest.expect)(relatedUser).toBeDefined();
-		});
-	});
-});
-
-//#endregion

package/dist/__tests__/KyselyFactory.spec.d.cts

@@ -1 +0,0 @@
-export { };

package/dist/__tests__/KyselyFactory.spec.d.mts

@@ -1 +0,0 @@
-export { };