@geekmidas/testkit 0.0.11 → 0.0.13

package/dist/__tests__/ObjectionFactory.spec.cjs

@@ -1,8 +1,13 @@
 const require_chunk = require('../chunk-CUT6urMc.cjs');
 require('../Factory-WMhTNZ9S.cjs');
-const require_faker = require('../faker-SMN4ira4.cjs');
-const require_ObjectionFactory = require('../ObjectionFactory-Wq80ypMM.cjs');
-const require_helpers = require('../helpers-CNMBePuj.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-CruLTRRi.cjs');
+require('../VitestObjectionTransactionIsolator-DyqLp_in.cjs');
+const require_objection = require('../objection-CCD8fMLj.cjs');
+const require_helpers = require('../helpers-Bf0nXhbu.cjs');
 const vitest = require_chunk.__toESM(require("vitest"));
 const objection = require_chunk.__toESM(require("objection"));
 
@@ -13,10 +18,6 @@ var User = class extends objection.Model {
 	}
 	id;
 	name;
-	email;
-	role;
-	createdAt;
-	updatedAt;
 };
 var Post = class extends objection.Model {
 	static get tableName() {
@@ -24,478 +25,315 @@ var Post = class extends objection.Model {
 	}
 	id;
 	title;
-	content;
-	userId;
-	published;
-	createdAt;
-	updatedAt;
+	user_id;
 };
-var Comment = class extends objection.Model {
-	static get tableName() {
-		return "comments";
-	}
-	id;
-	content;
-	postId;
-	userId;
-	createdAt;
-};
-vitest.describe.skip("ObjectionFactory", () => {
-	let factory;
-	let db;
-	let trx;
-	let cleanup;
-	(0, vitest.beforeAll)(async () => {
-		const setup = await require_helpers.setupKnexTest();
-		db = setup.db;
-		trx = setup.trx;
-		cleanup = setup.cleanup;
-		User.knex(trx);
-		Post.knex(trx);
-		Comment.knex(trx);
+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);
 	});
-	(0, vitest.afterAll)(async () => {
-		await cleanup();
+	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();
 	});
-	(0, vitest.describe)("constructor", () => {
-		(0, vitest.it)("should create an ObjectionFactory instance", () => {
-			const builders = {};
-			const seeds = {};
-			factory = new require_ObjectionFactory.ObjectionFactory(builders, seeds, trx);
-			(0, vitest.expect)(factory).toBeInstanceOf(require_ObjectionFactory.ObjectionFactory);
-		});
+	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();
 	});
-	(0, vitest.describe)("insert method", () => {
-		(0, vitest.it)("should call builder and insert the record", async () => {
-			const userBuilder = async (attrs$1, factory$1, db$1) => {
-				return User.fromJson({
-					name: attrs$1.name || "Default Name",
-					email: attrs$1.email || `user${Date.now()}@example.com`,
-					role: attrs$1.role || "user",
-					createdAt: /* @__PURE__ */ new Date(),
-					updatedAt: /* @__PURE__ */ new Date()
-				});
-			};
-			const builders = { user: userBuilder };
-			factory = new require_ObjectionFactory.ObjectionFactory(builders, {}, trx);
-			const attrs = {
-				name: "John Doe",
-				email: "john@example.com"
-			};
-			const result = await factory.insert("user", attrs);
+	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("John Doe");
-			(0, vitest.expect)(result.email).toBe("john@example.com");
+			(0, vitest.expect)(result.name).toBe("User");
 			(0, vitest.expect)(result.id).toBeDefined();
 		});
-		(0, vitest.it)("should use empty object as default attributes", async () => {
-			const userBuilder = async (attrs, factory$1, db$1) => {
-				return User.fromJson({
-					name: "Default Name",
-					email: `user${Date.now()}@example.com`,
-					role: "user",
-					createdAt: /* @__PURE__ */ new Date(),
-					updatedAt: /* @__PURE__ */ new Date()
-				});
-			};
-			const builders = { user: userBuilder };
-			factory = new require_ObjectionFactory.ObjectionFactory(builders, {}, trx);
-			const result = await factory.insert("user");
+	});
+	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.name).toBe("Default Name");
 			(0, vitest.expect)(result.id).toBeDefined();
 		});
-		(0, vitest.it)("should throw error for non-existent factory", async () => {
-			factory = new require_ObjectionFactory.ObjectionFactory({}, {}, trx);
-			await (0, vitest.expect)(factory.insert("nonExistent")).rejects.toThrow("Factory \"nonExistent\" does not exist");
-		});
-		(0, vitest.it)("should handle builder that returns a promise", async () => {
-			const userBuilder = async (attrs, factory$1, db$1) => {
-				await new Promise((resolve) => setTimeout(resolve, 10));
-				return User.fromJson({
-					name: attrs.name || "Default Name",
-					email: `async${Date.now()}@example.com`,
-					role: "user",
-					createdAt: /* @__PURE__ */ new Date(),
-					updatedAt: /* @__PURE__ */ new Date()
-				});
-			};
-			const builders = { user: userBuilder };
-			factory = new require_ObjectionFactory.ObjectionFactory(builders, {}, trx);
-			const result = await factory.insert("user", { name: "Jane" });
+	});
+	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("Jane");
+			(0, vitest.expect)(result.name).toBe("Default Name");
+			(0, vitest.expect)(result.id).toBeDefined();
 		});
 	});
-	(0, vitest.describe)("insertMany method", () => {
-		(0, vitest.it)("should insert multiple records with same attributes", async () => {
-			const userBuilder = async (attrs$1, factory$1, db$1) => {
-				return User.fromJson({
-					name: attrs$1.name || "Default Name",
-					email: `user${Date.now()}-${Math.random()}@example.com`,
-					role: "user",
-					createdAt: /* @__PURE__ */ new Date(),
-					updatedAt: /* @__PURE__ */ new Date()
-				});
-			};
-			const builders = { user: userBuilder };
-			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();
-			});
-		});
-		(0, vitest.it)("should insert multiple records with dynamic attributes", async () => {
-			const userBuilder = async (attrs, factory$1, db$1) => {
-				return User.fromJson({
-					name: attrs.name || "Default Name",
-					email: `user${Date.now()}-${Math.random()}@example.com`,
-					role: "user",
-					createdAt: /* @__PURE__ */ new Date(),
-					updatedAt: /* @__PURE__ */ new Date()
-				});
-			};
-			const builders = { user: userBuilder };
-			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();
-			});
-		});
-		(0, vitest.it)("should use empty object as default attributes for insertMany", async () => {
-			const userBuilder = async (attrs, factory$1, db$1) => {
-				return User.fromJson({
-					name: "Default Name",
-					email: `user${Date.now()}-${Math.random()}@example.com`,
-					role: "user",
-					createdAt: /* @__PURE__ */ new Date(),
-					updatedAt: /* @__PURE__ */ new Date()
-				});
-			};
-			const builders = { user: userBuilder };
-			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"
 			});
-		});
-		(0, vitest.it)("should throw error for non-existent builder in insertMany", async () => {
-			factory = new require_ObjectionFactory.ObjectionFactory({}, {}, trx);
-			await (0, vitest.expect)(factory.insertMany(2, "nonExistent")).rejects.toThrow("Builder \"nonExistent\" is not registered");
-		});
+		};
+		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");
 	});
-	(0, vitest.describe)("seed method", () => {
-		(0, vitest.it)("should execute seed function", async () => {
-			const userBuilder = async (attrs$1, factory$1, db$1) => {
-				return User.fromJson({
-					name: attrs$1.name || "Default Name",
-					email: attrs$1.email || `admin${Date.now()}@example.com`,
-					role: "admin",
-					createdAt: /* @__PURE__ */ new Date(),
-					updatedAt: /* @__PURE__ */ new Date()
-				});
-			};
-			const builders = { user: userBuilder };
-			const createAdminSeed = async (attrs$1, factory$1, db$1) => {
-				return await factory$1.insert("user", {
-					name: attrs$1.name || "Admin User",
-					email: "admin@example.com",
-					role: "admin"
-				});
-			};
-			const seeds = { createAdmin: createAdminSeed };
-			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.role).toBe("admin");
-			(0, vitest.expect)(result.id).toBeDefined();
-		});
-		(0, vitest.it)("should use empty object as default attributes for seed", async () => {
-			const userBuilder = async (attrs, factory$1, db$1) => {
-				return User.fromJson({
-					name: "Default Admin",
-					email: `admin${Date.now()}@example.com`,
-					role: "admin",
-					createdAt: /* @__PURE__ */ new Date(),
-					updatedAt: /* @__PURE__ */ new Date()
-				});
-			};
-			const builders = { user: userBuilder };
-			const createAdminSeed = async (attrs, factory$1, db$1) => {
-				return await factory$1.insert("user", {
-					name: "Default Admin",
-					role: "admin"
-				});
-			};
-			const seeds = { createAdmin: createAdminSeed };
-			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");
-			(0, vitest.expect)(result.role).toBe("admin");
-		});
-		(0, vitest.it)("should throw error for non-existent seed", () => {
-			factory = new require_ObjectionFactory.ObjectionFactory({}, {}, trx);
-			(0, vitest.expect)(() => factory.seed("nonExistent")).toThrow("Seed \"nonExistent\" is not registered");
-		});
-		(0, vitest.it)("should pass factory and db to seed function", async () => {
-			const userBuilder = async (attrs, factory$1, db$1) => {
-				return User.fromJson({
-					name: attrs.name || "Test User",
-					email: `test${Date.now()}@example.com`,
-					role: "user",
-					createdAt: /* @__PURE__ */ new Date(),
-					updatedAt: /* @__PURE__ */ new Date()
-				});
-			};
-			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 };
-			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 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");
 	});
-	(0, vitest.describe)("createSeed static method", () => {
-		(0, vitest.it)("should return the seed function unchanged", () => {
-			const seedFn = async (attrs, factory$1, db$1) => {
-				return {
-					id: 1,
-					name: "test"
-				};
+	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);
-		});
+		};
+		const result = require_ObjectionFactory.ObjectionFactory.createSeed(seedFn);
+		(0, vitest.expect)(result).toBe(seedFn);
 	});
-	(0, vitest.describe)("createBuilder static method", () => {
-		(0, vitest.it)("should create a builder function with auto-insert", async () => {
-			const userBuilder = require_ObjectionFactory.ObjectionFactory.createBuilder(User, (attrs, factory$1, db$1, faker$1) => ({
-				name: faker$1.person.fullName(),
-				email: faker$1.internet.email(),
-				role: "user",
-				createdAt: /* @__PURE__ */ new Date(),
-				updatedAt: /* @__PURE__ */ new Date(),
-				...attrs
-			}));
-			const builders = { user: userBuilder };
-			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.email).toMatch(/@/);
-			(0, vitest.expect)(result.id).toBeDefined();
-		});
-		(0, vitest.it)("should create a builder function without auto-insert", async () => {
-			const userBuilder = require_ObjectionFactory.ObjectionFactory.createBuilder(User, (attrs) => ({
-				name: "No Insert User",
-				email: "noinsert@example.com",
-				role: "user",
-				createdAt: /* @__PURE__ */ new Date(),
-				updatedAt: /* @__PURE__ */ new Date(),
+	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
-			}), false);
-			const builders = { user: userBuilder };
-			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();
-		});
-		(0, vitest.it)("should pass all parameters to the item function", async () => {
-			let capturedFactory;
-			let capturedDb;
-			let capturedFaker;
-			const userBuilder = require_ObjectionFactory.ObjectionFactory.createBuilder(User, (attrs, factory$1, db$1, fakerInstance) => {
-				capturedFactory = factory$1;
-				capturedDb = db$1;
-				capturedFaker = fakerInstance;
-				return {
-					name: "Test User",
-					email: "test@example.com",
-					role: "user",
-					createdAt: /* @__PURE__ */ new Date(),
-					updatedAt: /* @__PURE__ */ new Date(),
-					...attrs
-				};
-			});
-			const builders = { user: userBuilder };
-			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);
-		});
-		(0, vitest.it)("should handle async item functions", async () => {
-			const userBuilder = require_ObjectionFactory.ObjectionFactory.createBuilder(User, async (attrs, factory$1, db$1, faker$1) => {
-				await new Promise((resolve) => setTimeout(resolve, 10));
-				return {
-					name: "Async User",
-					email: faker$1.internet.email(),
-					role: "user",
-					createdAt: /* @__PURE__ */ new Date(),
-					updatedAt: /* @__PURE__ */ new Date(),
-					...attrs
-				};
-			});
-			const builders = { user: userBuilder };
-			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();
-		});
-		(0, vitest.it)("should work without item function", async () => {
-			const userBuilder = require_ObjectionFactory.ObjectionFactory.createBuilder(User);
-			const builders = { user: userBuilder };
-			factory = new require_ObjectionFactory.ObjectionFactory(builders, {}, trx);
-			const attrs = {
-				name: "Manual User",
-				email: "manual@example.com",
-				role: "user",
-				createdAt: /* @__PURE__ */ new Date(),
-				updatedAt: /* @__PURE__ */ new Date()
 			};
-			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.email).toBe("manual@example.com");
-			(0, vitest.expect)(result.id).toBeDefined();
-		});
-		(0, vitest.it)("should allow overriding default values", async () => {
-			const userBuilder = require_ObjectionFactory.ObjectionFactory.createBuilder(User, (attrs, factory$1, db$1, faker$1) => ({
-				name: "Default Name",
-				email: "default@example.com",
-				role: "user",
-				createdAt: /* @__PURE__ */ new Date(),
-				updatedAt: /* @__PURE__ */ new Date(),
-				...attrs
-			}));
-			const builders = { user: userBuilder };
-			factory = new require_ObjectionFactory.ObjectionFactory(builders, {}, trx);
-			const result = await factory.insert("user", {
-				name: "Override Name",
-				email: "override@example.com"
-			});
-			(0, vitest.expect)(result).toBeInstanceOf(User);
-			(0, vitest.expect)(result.name).toBe("Override Name");
-			(0, vitest.expect)(result.email).toBe("override@example.com");
-			(0, vitest.expect)(result.role).toBe("user");
 		});
+		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);
 	});
-	(0, vitest.describe)("error handling", () => {
-		(0, vitest.it)("should handle builder errors gracefully", async () => {
-			const userBuilder = async (attrs, factory$1, db$1) => {
-				throw new Error("Builder failed");
-			};
-			const builders = { user: userBuilder };
-			factory = new require_ObjectionFactory.ObjectionFactory(builders, {}, trx);
-			await (0, vitest.expect)(factory.insert("user")).rejects.toThrow("Builder failed");
-		});
-		(0, vitest.it)("should handle invalid model data gracefully", async () => {
-			const userBuilder = async (attrs, factory$1, db$1) => {
-				return User.fromJson({ invalidField: "invalid" });
-			};
-			const builders = { user: userBuilder };
-			factory = new require_ObjectionFactory.ObjectionFactory(builders, {}, trx);
-			await (0, vitest.expect)(factory.insert("user")).rejects.toThrow();
-		});
-		(0, vitest.it)("should handle seed function errors gracefully", async () => {
-			const failingSeed = async (attrs, factory$1, db$1) => {
-				throw new Error("Seed failed");
+	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 seeds = { failingSeed };
-			factory = new require_ObjectionFactory.ObjectionFactory({}, seeds, trx);
-			await (0, vitest.expect)(factory.seed("failingSeed")).rejects.toThrow("Seed failed");
 		});
+		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();
 	});
-	(0, vitest.describe)("type safety and integration", () => {
-		(0, vitest.it)("should work with typed builders and seeds", async () => {
-			const userBuilder = async (attrs, factory$1, db$1) => {
-				return User.fromJson({
-					name: attrs.name || "Default User",
-					email: attrs.email || `user${Date.now()}@example.com`,
-					role: "user",
-					createdAt: /* @__PURE__ */ new Date(),
-					updatedAt: /* @__PURE__ */ new Date()
-				});
-			};
-			const adminSeed = async (attrs, factory$1, db$1) => {
-				return factory$1.insert("user", {
-					name: "Admin",
-					email: "admin@example.com",
-					role: "admin"
-				});
-			};
-			const builders = { user: userBuilder };
-			const seeds = { admin: adminSeed };
-			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");
-		});
-		(0, vitest.it)("should handle complex builder scenarios", async () => {
-			const userBuilder = async (attrs, factory$1, db$1) => {
-				return User.fromJson({
-					name: attrs.name || "Default User",
-					email: attrs.email || `user${Date.now()}@example.com`,
-					role: "user",
-					createdAt: /* @__PURE__ */ new Date(),
-					updatedAt: /* @__PURE__ */ new Date()
-				});
-			};
-			const postBuilder = async (attrs, factory$1, db$1) => {
-				if (!attrs.userId) {
-					const user = await factory$1.insert("user");
-					return Post.fromJson({
-						title: attrs.title || "Default Post",
-						content: attrs.content || "Default content",
-						userId: user.id,
-						published: attrs.published || false,
-						createdAt: /* @__PURE__ */ new Date(),
-						updatedAt: /* @__PURE__ */ new Date()
-					});
-				}
+	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",
-					content: attrs.content || "Default content",
-					userId: attrs.userId,
-					published: attrs.published || false,
-					createdAt: /* @__PURE__ */ new Date(),
-					updatedAt: /* @__PURE__ */ new Date()
+					user_id: user.id
 				});
-			};
-			const builders = {
-				user: userBuilder,
-				post: postBuilder
-			};
-			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.userId).toBeDefined();
-			(0, vitest.expect)(typeof post.userId).toBe("number");
-		});
+			}
+			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");
 	});
 });