@geekmidas/testkit 0.0.15 → 0.0.16

package/dist/__tests__/KyselyFactory.spec.mjs

@@ -1,234 +0,0 @@
-import "../Factory-z2m01hMj.mjs";
-import "../faker-BGKYFoCT.mjs";
-import { KyselyFactory } from "../KyselyFactory-BcYkC0t2.mjs";
-import "../PostgresMigrator-DxPC_gGu.mjs";
-import "../PostgresKyselyMigrator-Bdhl251C.mjs";
-import "../VitestTransactionIsolator-CskiiJbW.mjs";
-import "../VitestKyselyTransactionIsolator-BxjlD1YM.mjs";
-import { createKyselyDb } from "../helpers-BuPmgzyQ.mjs";
-import { wrapVitestKyselyTransaction } from "../kysely-C3h7kitU.mjs";
-import { TEST_DATABASE_CONFIG, createTestTables } from "../helpers-B4TXg3Wp.mjs";
-import pg from "pg";
-import { describe, expect, it } from "vitest";
-
-//#region src/__tests__/KyselyFactory.spec.ts
-const db = () => createKyselyDb(TEST_DATABASE_CONFIG);
-const itWithTransaction = wrapVitestKyselyTransaction(it, db, 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("users", async (attrs) => ({
-				name: "John Doe",
-				email: `user${Date.now()}@example.com`,
-				createdAt: /* @__PURE__ */ new Date()
-			}));
-			const builders = { user: userBuilder };
-			const factory = new KyselyFactory(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("users", async (attrs) => ({
-				name: "John Doe",
-				email: `user${Date.now()}@example.com`,
-				createdAt: /* @__PURE__ */ new Date()
-			}));
-			const builders = { user: userBuilder };
-			const factory = new KyselyFactory(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("users", async (attrs) => ({
-				name: "John Doe",
-				email: `user${Date.now()}@example.com`,
-				createdAt: /* @__PURE__ */ new Date()
-			}));
-			const postBuilder = 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 KyselyFactory(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({}, {}, trx);
-			await expect(factory.insert("nonExistent")).rejects.toThrow("Factory \"nonExistent\" does not exist");
-		});
-	});
-	describe("KyselyFactory.insertMany", () => {
-		itWithTransaction("should insert multiple records with same attributes", async ({ trx }) => {
-			const userBuilder = 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 KyselyFactory(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("users", async (attrs) => ({
-				email: `user${Date.now()}-${Math.random()}@example.com`,
-				createdAt: /* @__PURE__ */ new Date()
-			}));
-			const builders = { user: userBuilder };
-			const factory = new KyselyFactory(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({}, {}, trx);
-			await expect(factory.insertMany(2, "nonExistent")).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("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 KyselyFactory(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("users", async (attrs) => ({
-				name: "John Doe",
-				email: `user${Date.now()}@example.com`,
-				createdAt: /* @__PURE__ */ new Date()
-			}));
-			const builders = { user: userBuilder };
-			const seeds = { createAdminUser: 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 KyselyFactory(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("users", async (attrs) => ({
-				name: "John Doe",
-				email: `user${Date.now()}@example.com`,
-				createdAt: /* @__PURE__ */ new Date()
-			}));
-			const builders = { user: userBuilder };
-			const seeds = { createCustomUser: KyselyFactory.createSeed(async (attrs, factory$1, db$1) => {
-				return await factory$1.insert("user", attrs);
-			}) };
-			const factory = new KyselyFactory(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({}, {}, trx);
-			expect(() => factory.seed("nonExistent")).toThrow("Seed \"nonExistent\" is not registered");
-		});
-	});
-	describe("Factory integration", () => {
-		itWithTransaction("should work with controlled transactions", async ({ trx }) => {
-			const userBuilder = 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 KyselyFactory(builders, {}, trx);
-			const user = await factory.insert("user");
-			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("users", async (attrs) => ({
-				name: "John Doe",
-				email: `user${Date.now()}@example.com`,
-				createdAt: /* @__PURE__ */ new Date()
-			}));
-			const postBuilder = 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 KyselyFactory(builders, {}, trx);
-			const post = await factory.insert("post");
-			expect(post.userId).toBeDefined();
-			const relatedUser = await trx.selectFrom("users").selectAll().where("id", "=", post.userId).executeTakeFirst();
-			expect(relatedUser).toBeDefined();
-		});
-	});
-});
-
-//#endregion

package/dist/__tests__/ObjectionFactory.spec.cjs

@@ -1,340 +0,0 @@
-const require_chunk = require('../chunk-CUT6urMc.cjs');
-require('../Factory-WMhTNZ9S.cjs');
-const require_faker = require('../faker-B14IEMIN.cjs');
-const require_ObjectionFactory = require('../ObjectionFactory-CDriunkS.cjs');
-require('../PostgresMigrator-DFcNdCvD.cjs');
-require('../PostgresObjectionMigrator-BG6ymgnt.cjs');
-require('../VitestTransactionIsolator-BQ5FpLtC.cjs');
-require('../VitestObjectionTransactionIsolator-DzeF4UAq.cjs');
-const require_objection = require('../objection-BpLv_ZfC.cjs');
-const require_helpers = require('../helpers-Bf0nXhbu.cjs');
-const vitest = require_chunk.__toESM(require("vitest"));
-const objection = require_chunk.__toESM(require("objection"));
-
-//#region src/__tests__/ObjectionFactory.spec.ts
-var User = class extends objection.Model {
-	static get tableName() {
-		return "users";
-	}
-	id;
-	name;
-};
-var Post = class extends objection.Model {
-	static get tableName() {
-		return "posts";
-	}
-	id;
-	title;
-	user_id;
-};
-const it = require_objection.wrapVitestObjectionTransaction(vitest.test, require_helpers.createKnexDb, require_helpers.createTestTablesKnex);
-(0, vitest.describe)("ObjectionFactory", () => {
-	it("should create an ObjectionFactory instance", ({ trx }) => {
-		const builders = {};
-		const seeds = {};
-		const factory = new require_ObjectionFactory.ObjectionFactory(builders, seeds, trx);
-		(0, vitest.expect)(factory).toBeInstanceOf(require_ObjectionFactory.ObjectionFactory);
-	});
-	it("should call builder and insert the record", async ({ trx }) => {
-		const userBuilder = async (attrs$1, factory$1, db) => {
-			return User.fromJson({ name: attrs$1.name || "Default Name" });
-		};
-		const builders = { user: userBuilder };
-		const factory = new require_ObjectionFactory.ObjectionFactory(builders, {}, trx);
-		const attrs = {
-			name: "John Doe",
-			email: "john@example.com"
-		};
-		const result = await factory.insert("user", attrs);
-		(0, vitest.expect)(result).toBeInstanceOf(User);
-		(0, vitest.expect)(result.name).toBe("John Doe");
-		(0, vitest.expect)(result.id).toBeDefined();
-	});
-	it("should use empty object as default attributes", async ({ trx }) => {
-		const userBuilder = async (attrs, factory$1, db) => {
-			return User.fromJson({ name: "Default Name" });
-		};
-		const builders = { user: userBuilder };
-		const factory = new require_ObjectionFactory.ObjectionFactory(builders, {}, trx);
-		const result = await factory.insert("user");
-		(0, vitest.expect)(result).toBeInstanceOf(User);
-		(0, vitest.expect)(result.name).toBe("Default Name");
-		(0, vitest.expect)(result.id).toBeDefined();
-	});
-	it("should throw error for non-existent factory", async ({ trx }) => {
-		const factory = new require_ObjectionFactory.ObjectionFactory({}, {}, trx);
-		await (0, vitest.expect)(factory.insert("nonExistent")).rejects.toThrow("Factory \"nonExistent\" does not exist");
-	});
-	it("should handle builder that returns a promise", async ({ trx }) => {
-		const userBuilder = async (attrs, factory$1, db) => {
-			await new Promise((resolve) => setTimeout(resolve, 10));
-			return User.fromJson({ name: attrs.name || "Default Name" });
-		};
-		const builders = { user: userBuilder };
-		const factory = new require_ObjectionFactory.ObjectionFactory(builders, {}, trx);
-		const result = await factory.insert("user", { name: "Jane" });
-		(0, vitest.expect)(result).toBeInstanceOf(User);
-		(0, vitest.expect)(result.name).toBe("Jane");
-	});
-	it("should insert multiple records with same attributes", async ({ trx }) => {
-		const userBuilder = async (attrs$1, factory$1, db) => {
-			return User.fromJson({ name: attrs$1.name || "Default Name" });
-		};
-		const builders = { user: userBuilder };
-		const factory = new require_ObjectionFactory.ObjectionFactory(builders, {}, trx);
-		const attrs = { name: "User" };
-		const results = await factory.insertMany(3, "user", attrs);
-		(0, vitest.expect)(results).toHaveLength(3);
-		results.forEach((result) => {
-			(0, vitest.expect)(result).toBeInstanceOf(User);
-			(0, vitest.expect)(result.name).toBe("User");
-			(0, vitest.expect)(result.id).toBeDefined();
-		});
-	});
-	it("should insert multiple records with dynamic attributes", async ({ trx }) => {
-		const userBuilder = async (attrs, factory$1, db) => {
-			return User.fromJson({ name: attrs.name || "Default Name" });
-		};
-		const builders = { user: userBuilder };
-		const factory = new require_ObjectionFactory.ObjectionFactory(builders, {}, trx);
-		const attrsFn = (idx) => ({ name: `User ${idx}` });
-		const results = await factory.insertMany(2, "user", attrsFn);
-		(0, vitest.expect)(results).toHaveLength(2);
-		(0, vitest.expect)(results[0].name).toBe("User 0");
-		(0, vitest.expect)(results[1].name).toBe("User 1");
-		results.forEach((result) => {
-			(0, vitest.expect)(result).toBeInstanceOf(User);
-			(0, vitest.expect)(result.id).toBeDefined();
-		});
-	});
-	it("should use empty object as default attributes for insertMany", async ({ trx }) => {
-		const userBuilder = async (attrs, factory$1, db) => {
-			return User.fromJson({ name: "Default Name" });
-		};
-		const builders = { user: userBuilder };
-		const factory = new require_ObjectionFactory.ObjectionFactory(builders, {}, trx);
-		const results = await factory.insertMany(2, "user");
-		(0, vitest.expect)(results).toHaveLength(2);
-		results.forEach((result) => {
-			(0, vitest.expect)(result).toBeInstanceOf(User);
-			(0, vitest.expect)(result.name).toBe("Default Name");
-			(0, vitest.expect)(result.id).toBeDefined();
-		});
-	});
-	it("should throw error for non-existent builder in insertMany", async ({ trx }) => {
-		const factory = new require_ObjectionFactory.ObjectionFactory({}, {}, trx);
-		await (0, vitest.expect)(factory.insertMany(2, "nonExistent")).rejects.toThrow("Builder \"nonExistent\" is not registered");
-	});
-	it("should execute seed function", async ({ trx }) => {
-		const userBuilder = async (attrs$1, factory$1, db) => {
-			return User.fromJson({ name: attrs$1.name || "Default Name" });
-		};
-		const builders = { user: userBuilder };
-		const createAdminSeed = async (attrs$1, factory$1, db) => {
-			return await factory$1.insert("user", { name: attrs$1.name || "Admin User" });
-		};
-		const seeds = { createAdmin: createAdminSeed };
-		const factory = new require_ObjectionFactory.ObjectionFactory(builders, seeds, trx);
-		const attrs = { name: "Super Admin" };
-		const result = await factory.seed("createAdmin", attrs);
-		(0, vitest.expect)(result).toBeInstanceOf(User);
-		(0, vitest.expect)(result.name).toBe("Super Admin");
-		(0, vitest.expect)(result.id).toBeDefined();
-	});
-	it("should use empty object as default attributes for seed", async ({ trx }) => {
-		const userBuilder = async (attrs, factory$1, db) => {
-			return User.fromJson({ name: "Default Admin" });
-		};
-		const builders = { user: userBuilder };
-		const createAdminSeed = async (attrs, factory$1, db) => {
-			return await factory$1.insert("user", {
-				name: "Default Admin",
-				role: "admin"
-			});
-		};
-		const seeds = { createAdmin: createAdminSeed };
-		const factory = new require_ObjectionFactory.ObjectionFactory(builders, seeds, trx);
-		const result = await factory.seed("createAdmin");
-		(0, vitest.expect)(result).toBeInstanceOf(User);
-		(0, vitest.expect)(result.name).toBe("Default Admin");
-	});
-	it("should throw error for non-existent seed", ({ trx }) => {
-		const factory = new require_ObjectionFactory.ObjectionFactory({}, {}, trx);
-		(0, vitest.expect)(() => factory.seed("nonExistent")).toThrow("Seed \"nonExistent\" is not registered");
-	});
-	it("should pass factory and db to seed function", async ({ trx }) => {
-		const userBuilder = async (attrs, factory$1, db) => {
-			return User.fromJson({ name: attrs.name || "Test User" });
-		};
-		const builders = { user: userBuilder };
-		const complexSeed = async (attrs, passedFactory, passedDb) => {
-			(0, vitest.expect)(passedFactory).toBe(factory);
-			(0, vitest.expect)(passedDb).toBe(trx);
-			return await passedFactory.insert("user", { name: `Complex ${attrs.data}` });
-		};
-		const seeds = { complexSeed };
-		const factory = new require_ObjectionFactory.ObjectionFactory(builders, seeds, trx);
-		const result = await factory.seed("complexSeed", { data: "test" });
-		(0, vitest.expect)(result).toBeInstanceOf(User);
-		(0, vitest.expect)(result.name).toBe("Complex test");
-	});
-	it("should return the seed function unchanged", () => {
-		const seedFn = async (attrs, factory, db) => {
-			return {
-				id: 1,
-				name: "test"
-			};
-		};
-		const result = require_ObjectionFactory.ObjectionFactory.createSeed(seedFn);
-		(0, vitest.expect)(result).toBe(seedFn);
-	});
-	it("should create a builder function with auto-insert", async ({ trx }) => {
-		const userBuilder = require_ObjectionFactory.ObjectionFactory.createBuilder(User, (attrs, factory$1, db, faker$1) => ({
-			name: faker$1.person.fullName(),
-			...attrs
-		}));
-		const builders = { user: userBuilder };
-		const factory = new require_ObjectionFactory.ObjectionFactory(builders, {}, trx);
-		const result = await factory.insert("user", { name: "Test User" });
-		(0, vitest.expect)(result).toBeInstanceOf(User);
-		(0, vitest.expect)(result.name).toBe("Test User");
-		(0, vitest.expect)(result.id).toBeDefined();
-	});
-	it("should create a builder function without auto-insert", async ({ trx }) => {
-		const userBuilder = require_ObjectionFactory.ObjectionFactory.createBuilder(User, (attrs) => ({
-			name: "No Insert User",
-			...attrs
-		}), false);
-		const builders = { user: userBuilder };
-		const factory = new require_ObjectionFactory.ObjectionFactory(builders, {}, trx);
-		const result = await factory.insert("user");
-		(0, vitest.expect)(result).toBeInstanceOf(User);
-		(0, vitest.expect)(result.name).toBe("No Insert User");
-		(0, vitest.expect)(result.id).toBeDefined();
-	});
-	it("should pass all parameters to the item function", async ({ trx }) => {
-		let capturedFactory;
-		let capturedDb;
-		let capturedFaker;
-		const userBuilder = require_ObjectionFactory.ObjectionFactory.createBuilder(User, (attrs, factory$1, db, fakerInstance) => {
-			capturedFactory = factory$1;
-			capturedDb = db;
-			capturedFaker = fakerInstance;
-			return {
-				name: "Test User",
-				...attrs
-			};
-		});
-		const builders = { user: userBuilder };
-		const factory = new require_ObjectionFactory.ObjectionFactory(builders, {}, trx);
-		await factory.insert("user");
-		(0, vitest.expect)(capturedFactory).toBe(factory);
-		(0, vitest.expect)(capturedDb).toBe(trx);
-		(0, vitest.expect)(capturedFaker).toBe(require_faker.faker);
-	});
-	it("should handle async item functions", async ({ trx }) => {
-		const userBuilder = require_ObjectionFactory.ObjectionFactory.createBuilder(User, async (attrs, factory$1, db, faker$1) => {
-			await new Promise((resolve) => setTimeout(resolve, 10));
-			return {
-				name: "Async User",
-				...attrs
-			};
-		});
-		const builders = { user: userBuilder };
-		const factory = new require_ObjectionFactory.ObjectionFactory(builders, {}, trx);
-		const result = await factory.insert("user");
-		(0, vitest.expect)(result).toBeInstanceOf(User);
-		(0, vitest.expect)(result.name).toBe("Async User");
-		(0, vitest.expect)(result.id).toBeDefined();
-	});
-	it("should work without item function", async ({ trx }) => {
-		const userBuilder = require_ObjectionFactory.ObjectionFactory.createBuilder(User);
-		const builders = { user: userBuilder };
-		const factory = new require_ObjectionFactory.ObjectionFactory(builders, {}, trx);
-		const attrs = { name: "Manual User" };
-		const result = await factory.insert("user", attrs);
-		(0, vitest.expect)(result).toBeInstanceOf(User);
-		(0, vitest.expect)(result.name).toBe("Manual User");
-		(0, vitest.expect)(result.id).toBeDefined();
-	});
-	it("should allow overriding default values", async ({ trx }) => {
-		const userBuilder = require_ObjectionFactory.ObjectionFactory.createBuilder(User, (attrs, factory$1, db, faker$1) => ({
-			name: "Default Name",
-			...attrs
-		}));
-		const builders = { user: userBuilder };
-		const factory = new require_ObjectionFactory.ObjectionFactory(builders, {}, trx);
-		const result = await factory.insert("user", { name: "Override Name" });
-		(0, vitest.expect)(result).toBeInstanceOf(User);
-		(0, vitest.expect)(result.name).toBe("Override Name");
-	});
-	it("should handle builder errors gracefully", async ({ trx }) => {
-		const userBuilder = async (attrs, factory$1, db) => {
-			throw new Error("Builder failed");
-		};
-		const builders = { user: userBuilder };
-		const factory = new require_ObjectionFactory.ObjectionFactory(builders, {}, trx);
-		await (0, vitest.expect)(factory.insert("user")).rejects.toThrow("Builder failed");
-	});
-	it("should handle invalid model data gracefully", async ({ trx }) => {
-		const userBuilder = async (attrs, factory$1, db) => {
-			return User.fromJson({ invalidField: "invalid" });
-		};
-		const builders = { user: userBuilder };
-		const factory = new require_ObjectionFactory.ObjectionFactory(builders, {}, trx);
-		await (0, vitest.expect)(factory.insert("user")).rejects.toThrow();
-	});
-	it("should handle seed function errors gracefully", async ({ trx }) => {
-		const failingSeed = async (attrs, factory$1, db) => {
-			throw new Error("Seed failed");
-		};
-		const seeds = { failingSeed };
-		const factory = new require_ObjectionFactory.ObjectionFactory({}, seeds, trx);
-		await (0, vitest.expect)(factory.seed("failingSeed")).rejects.toThrow("Seed failed");
-	});
-	it("should work with typed builders and seeds", async ({ trx }) => {
-		const userBuilder = async (attrs, factory$1, db) => {
-			return User.fromJson({ name: attrs.name || "Default User" });
-		};
-		const adminSeed = async (attrs, factory$1, db) => {
-			return factory$1.insert("user", { name: "Admin" });
-		};
-		const builders = { user: userBuilder };
-		const seeds = { admin: adminSeed };
-		const factory = new require_ObjectionFactory.ObjectionFactory(builders, seeds, trx);
-		(0, vitest.expect)(factory).toBeInstanceOf(require_ObjectionFactory.ObjectionFactory);
-		const admin = await factory.seed("admin", { isSuper: true });
-		(0, vitest.expect)(admin).toBeInstanceOf(User);
-		(0, vitest.expect)(admin.name).toBe("Admin");
-	});
-	it("should handle complex builder scenarios", async ({ trx }) => {
-		const userBuilder = async (attrs, factory$1, db) => {
-			return User.fromJson({ name: attrs.name || "Default User" });
-		};
-		const postBuilder = async (attrs, factory$1, db) => {
-			if (!attrs.user_id) {
-				const user = await factory$1.insert("user");
-				return Post.fromJson({
-					title: attrs.title || "Default Post",
-					user_id: user.id
-				});
-			}
-			return Post.fromJson({
-				title: attrs.title || "Default Post",
-				user_id: attrs.user_id
-			});
-		};
-		const builders = {
-			user: userBuilder,
-			post: postBuilder
-		};
-		const factory = new require_ObjectionFactory.ObjectionFactory(builders, {}, trx);
-		const post = await factory.insert("post", { title: "Test Post" });
-		(0, vitest.expect)(post).toBeInstanceOf(Post);
-		(0, vitest.expect)(post.title).toBe("Test Post");
-		(0, vitest.expect)(post.user_id).toBeDefined();
-		(0, vitest.expect)(typeof post.user_id).toBe("string");
-	});
-});
-
-//#endregion

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

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

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

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