@geekmidas/testkit 0.0.11 → 0.0.13

package/dist/__tests__/ObjectionFactory.spec.mjs

@@ -1,8 +1,13 @@
 import "../Factory-z2m01hMj.mjs";
-import { faker } from "../faker-CxKkEeYi.mjs";
-import { ObjectionFactory } from "../ObjectionFactory-aqM0dDW7.mjs";
-import { setupKnexTest } from "../helpers-BEmjyUVE.mjs";
-import { afterAll, beforeAll, describe, expect, it } from "vitest";
+import { faker } from "../faker-BGKYFoCT.mjs";
+import { ObjectionFactory } from "../ObjectionFactory-8hebmnai.mjs";
+import "../PostgresMigrator-DxPC_gGu.mjs";
+import "../PostgresObjectionMigrator-G4h5FLvU.mjs";
+import "../VitestTransactionIsolator-BWwK-ca6.mjs";
+import "../VitestObjectionTransactionIsolator-BPoLUFop.mjs";
+import { wrapVitestObjectionTransaction } from "../objection-lsMgM5gP.mjs";
+import { createKnexDb, createTestTablesKnex } from "../helpers-B4TXg3Wp.mjs";
+import { describe, expect, test } from "vitest";
 import { Model } from "objection";
 
 //#region src/__tests__/ObjectionFactory.spec.ts
@@ -12,10 +17,6 @@ var User = class extends Model {
 	}
 	id;
 	name;
-	email;
-	role;
-	createdAt;
-	updatedAt;
 };
 var Post = class extends Model {
 	static get tableName() {
@@ -23,478 +24,315 @@ var Post = class extends Model {
 	}
 	id;
 	title;
-	content;
-	userId;
-	published;
-	createdAt;
-	updatedAt;
+	user_id;
 };
-var Comment = class extends Model {
-	static get tableName() {
-		return "comments";
-	}
-	id;
-	content;
-	postId;
-	userId;
-	createdAt;
-};
-describe.skip("ObjectionFactory", () => {
-	let factory;
-	let db;
-	let trx;
-	let cleanup;
-	beforeAll(async () => {
-		const setup = await setupKnexTest();
-		db = setup.db;
-		trx = setup.trx;
-		cleanup = setup.cleanup;
-		User.knex(trx);
-		Post.knex(trx);
-		Comment.knex(trx);
+const it$1 = wrapVitestObjectionTransaction(test, createKnexDb(), createTestTablesKnex);
+describe("ObjectionFactory", () => {
+	it$1("should create an ObjectionFactory instance", ({ trx }) => {
+		const builders = {};
+		const seeds = {};
+		const factory = new ObjectionFactory(builders, seeds, trx);
+		expect(factory).toBeInstanceOf(ObjectionFactory);
 	});
-	afterAll(async () => {
-		await cleanup();
+	it$1("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 ObjectionFactory(builders, {}, trx);
+		const attrs = {
+			name: "John Doe",
+			email: "john@example.com"
+		};
+		const result = await factory.insert("user", attrs);
+		expect(result).toBeInstanceOf(User);
+		expect(result.name).toBe("John Doe");
+		expect(result.id).toBeDefined();
 	});
-	describe("constructor", () => {
-		it("should create an ObjectionFactory instance", () => {
-			const builders = {};
-			const seeds = {};
-			factory = new ObjectionFactory(builders, seeds, trx);
-			expect(factory).toBeInstanceOf(ObjectionFactory);
-		});
+	it$1("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 ObjectionFactory(builders, {}, trx);
+		const result = await factory.insert("user");
+		expect(result).toBeInstanceOf(User);
+		expect(result.name).toBe("Default Name");
+		expect(result.id).toBeDefined();
 	});
-	describe("insert method", () => {
-		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 ObjectionFactory(builders, {}, trx);
-			const attrs = {
-				name: "John Doe",
-				email: "john@example.com"
-			};
-			const result = await factory.insert("user", attrs);
+	it$1("should throw error for non-existent factory", async ({ trx }) => {
+		const factory = new ObjectionFactory({}, {}, trx);
+		await expect(factory.insert("nonExistent")).rejects.toThrow("Factory \"nonExistent\" does not exist");
+	});
+	it$1("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 ObjectionFactory(builders, {}, trx);
+		const result = await factory.insert("user", { name: "Jane" });
+		expect(result).toBeInstanceOf(User);
+		expect(result.name).toBe("Jane");
+	});
+	it$1("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 ObjectionFactory(builders, {}, trx);
+		const attrs = { name: "User" };
+		const results = await factory.insertMany(3, "user", attrs);
+		expect(results).toHaveLength(3);
+		results.forEach((result) => {
 			expect(result).toBeInstanceOf(User);
-			expect(result.name).toBe("John Doe");
-			expect(result.email).toBe("john@example.com");
+			expect(result.name).toBe("User");
 			expect(result.id).toBeDefined();
 		});
-		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 ObjectionFactory(builders, {}, trx);
-			const result = await factory.insert("user");
+	});
+	it$1("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 ObjectionFactory(builders, {}, trx);
+		const attrsFn = (idx) => ({ name: `User ${idx}` });
+		const results = await factory.insertMany(2, "user", attrsFn);
+		expect(results).toHaveLength(2);
+		expect(results[0].name).toBe("User 0");
+		expect(results[1].name).toBe("User 1");
+		results.forEach((result) => {
 			expect(result).toBeInstanceOf(User);
-			expect(result.name).toBe("Default Name");
 			expect(result.id).toBeDefined();
 		});
-		it("should throw error for non-existent factory", async () => {
-			factory = new ObjectionFactory({}, {}, trx);
-			await expect(factory.insert("nonExistent")).rejects.toThrow("Factory \"nonExistent\" does not exist");
-		});
-		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 ObjectionFactory(builders, {}, trx);
-			const result = await factory.insert("user", { name: "Jane" });
+	});
+	it$1("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 ObjectionFactory(builders, {}, trx);
+		const results = await factory.insertMany(2, "user");
+		expect(results).toHaveLength(2);
+		results.forEach((result) => {
 			expect(result).toBeInstanceOf(User);
-			expect(result.name).toBe("Jane");
+			expect(result.name).toBe("Default Name");
+			expect(result.id).toBeDefined();
 		});
 	});
-	describe("insertMany method", () => {
-		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 ObjectionFactory(builders, {}, trx);
-			const attrs = { name: "User" };
-			const results = await factory.insertMany(3, "user", attrs);
-			expect(results).toHaveLength(3);
-			results.forEach((result) => {
-				expect(result).toBeInstanceOf(User);
-				expect(result.name).toBe("User");
-				expect(result.id).toBeDefined();
-			});
-		});
-		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 ObjectionFactory(builders, {}, trx);
-			const attrsFn = (idx) => ({ name: `User ${idx}` });
-			const results = await factory.insertMany(2, "user", attrsFn);
-			expect(results).toHaveLength(2);
-			expect(results[0].name).toBe("User 0");
-			expect(results[1].name).toBe("User 1");
-			results.forEach((result) => {
-				expect(result).toBeInstanceOf(User);
-				expect(result.id).toBeDefined();
-			});
-		});
-		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 ObjectionFactory(builders, {}, trx);
-			const results = await factory.insertMany(2, "user");
-			expect(results).toHaveLength(2);
-			results.forEach((result) => {
-				expect(result).toBeInstanceOf(User);
-				expect(result.name).toBe("Default Name");
-				expect(result.id).toBeDefined();
+	it$1("should throw error for non-existent builder in insertMany", async ({ trx }) => {
+		const factory = new ObjectionFactory({}, {}, trx);
+		await expect(factory.insertMany(2, "nonExistent")).rejects.toThrow("Builder \"nonExistent\" is not registered");
+	});
+	it$1("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 ObjectionFactory(builders, seeds, trx);
+		const attrs = { name: "Super Admin" };
+		const result = await factory.seed("createAdmin", attrs);
+		expect(result).toBeInstanceOf(User);
+		expect(result.name).toBe("Super Admin");
+		expect(result.id).toBeDefined();
+	});
+	it$1("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"
 			});
-		});
-		it("should throw error for non-existent builder in insertMany", async () => {
-			factory = new ObjectionFactory({}, {}, trx);
-			await expect(factory.insertMany(2, "nonExistent")).rejects.toThrow("Builder \"nonExistent\" is not registered");
-		});
+		};
+		const seeds = { createAdmin: createAdminSeed };
+		const factory = new ObjectionFactory(builders, seeds, trx);
+		const result = await factory.seed("createAdmin");
+		expect(result).toBeInstanceOf(User);
+		expect(result.name).toBe("Default Admin");
 	});
-	describe("seed method", () => {
-		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 ObjectionFactory(builders, seeds, trx);
-			const attrs = { name: "Super Admin" };
-			const result = await factory.seed("createAdmin", attrs);
-			expect(result).toBeInstanceOf(User);
-			expect(result.name).toBe("Super Admin");
-			expect(result.role).toBe("admin");
-			expect(result.id).toBeDefined();
-		});
-		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 ObjectionFactory(builders, seeds, trx);
-			const result = await factory.seed("createAdmin");
-			expect(result).toBeInstanceOf(User);
-			expect(result.name).toBe("Default Admin");
-			expect(result.role).toBe("admin");
-		});
-		it("should throw error for non-existent seed", () => {
-			factory = new ObjectionFactory({}, {}, trx);
-			expect(() => factory.seed("nonExistent")).toThrow("Seed \"nonExistent\" is not registered");
-		});
-		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) => {
-				expect(passedFactory).toBe(factory);
-				expect(passedDb).toBe(trx);
-				return await passedFactory.insert("user", { name: `Complex ${attrs.data}` });
-			};
-			const seeds = { complexSeed };
-			factory = new ObjectionFactory(builders, seeds, trx);
-			const result = await factory.seed("complexSeed", { data: "test" });
-			expect(result).toBeInstanceOf(User);
-			expect(result.name).toBe("Complex test");
-		});
+	it$1("should throw error for non-existent seed", ({ trx }) => {
+		const factory = new ObjectionFactory({}, {}, trx);
+		expect(() => factory.seed("nonExistent")).toThrow("Seed \"nonExistent\" is not registered");
 	});
-	describe("createSeed static method", () => {
-		it("should return the seed function unchanged", () => {
-			const seedFn = async (attrs, factory$1, db$1) => {
-				return {
-					id: 1,
-					name: "test"
-				};
+	it$1("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) => {
+			expect(passedFactory).toBe(factory);
+			expect(passedDb).toBe(trx);
+			return await passedFactory.insert("user", { name: `Complex ${attrs.data}` });
+		};
+		const seeds = { complexSeed };
+		const factory = new ObjectionFactory(builders, seeds, trx);
+		const result = await factory.seed("complexSeed", { data: "test" });
+		expect(result).toBeInstanceOf(User);
+		expect(result.name).toBe("Complex test");
+	});
+	it$1("should return the seed function unchanged", () => {
+		const seedFn = async (attrs, factory, db) => {
+			return {
+				id: 1,
+				name: "test"
 			};
-			const result = ObjectionFactory.createSeed(seedFn);
-			expect(result).toBe(seedFn);
-		});
+		};
+		const result = ObjectionFactory.createSeed(seedFn);
+		expect(result).toBe(seedFn);
 	});
-	describe("createBuilder static method", () => {
-		it("should create a builder function with auto-insert", async () => {
-			const userBuilder = 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 ObjectionFactory(builders, {}, trx);
-			const result = await factory.insert("user", { name: "Test User" });
-			expect(result).toBeInstanceOf(User);
-			expect(result.name).toBe("Test User");
-			expect(result.email).toMatch(/@/);
-			expect(result.id).toBeDefined();
-		});
-		it("should create a builder function without auto-insert", async () => {
-			const userBuilder = ObjectionFactory.createBuilder(User, (attrs) => ({
-				name: "No Insert User",
-				email: "noinsert@example.com",
-				role: "user",
-				createdAt: /* @__PURE__ */ new Date(),
-				updatedAt: /* @__PURE__ */ new Date(),
+	it$1("should create a builder function with auto-insert", async ({ trx }) => {
+		const userBuilder = ObjectionFactory.createBuilder(User, (attrs, factory$1, db, faker$1) => ({
+			name: faker$1.person.fullName(),
+			...attrs
+		}));
+		const builders = { user: userBuilder };
+		const factory = new ObjectionFactory(builders, {}, trx);
+		const result = await factory.insert("user", { name: "Test User" });
+		expect(result).toBeInstanceOf(User);
+		expect(result.name).toBe("Test User");
+		expect(result.id).toBeDefined();
+	});
+	it$1("should create a builder function without auto-insert", async ({ trx }) => {
+		const userBuilder = ObjectionFactory.createBuilder(User, (attrs) => ({
+			name: "No Insert User",
+			...attrs
+		}), false);
+		const builders = { user: userBuilder };
+		const factory = new ObjectionFactory(builders, {}, trx);
+		const result = await factory.insert("user");
+		expect(result).toBeInstanceOf(User);
+		expect(result.name).toBe("No Insert User");
+		expect(result.id).toBeDefined();
+	});
+	it$1("should pass all parameters to the item function", async ({ trx }) => {
+		let capturedFactory;
+		let capturedDb;
+		let capturedFaker;
+		const userBuilder = 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 ObjectionFactory(builders, {}, trx);
-			const result = await factory.insert("user");
-			expect(result).toBeInstanceOf(User);
-			expect(result.name).toBe("No Insert User");
-			expect(result.id).toBeDefined();
-		});
-		it("should pass all parameters to the item function", async () => {
-			let capturedFactory;
-			let capturedDb;
-			let capturedFaker;
-			const userBuilder = 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 ObjectionFactory(builders, {}, trx);
-			await factory.insert("user");
-			expect(capturedFactory).toBe(factory);
-			expect(capturedDb).toBe(trx);
-			expect(capturedFaker).toBe(faker);
-		});
-		it("should handle async item functions", async () => {
-			const userBuilder = 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 ObjectionFactory(builders, {}, trx);
-			const result = await factory.insert("user");
-			expect(result).toBeInstanceOf(User);
-			expect(result.name).toBe("Async User");
-			expect(result.id).toBeDefined();
-		});
-		it("should work without item function", async () => {
-			const userBuilder = ObjectionFactory.createBuilder(User);
-			const builders = { user: userBuilder };
-			factory = new 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);
-			expect(result).toBeInstanceOf(User);
-			expect(result.name).toBe("Manual User");
-			expect(result.email).toBe("manual@example.com");
-			expect(result.id).toBeDefined();
-		});
-		it("should allow overriding default values", async () => {
-			const userBuilder = 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 ObjectionFactory(builders, {}, trx);
-			const result = await factory.insert("user", {
-				name: "Override Name",
-				email: "override@example.com"
-			});
-			expect(result).toBeInstanceOf(User);
-			expect(result.name).toBe("Override Name");
-			expect(result.email).toBe("override@example.com");
-			expect(result.role).toBe("user");
 		});
+		const builders = { user: userBuilder };
+		const factory = new ObjectionFactory(builders, {}, trx);
+		await factory.insert("user");
+		expect(capturedFactory).toBe(factory);
+		expect(capturedDb).toBe(trx);
+		expect(capturedFaker).toBe(faker);
 	});
-	describe("error handling", () => {
-		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 ObjectionFactory(builders, {}, trx);
-			await expect(factory.insert("user")).rejects.toThrow("Builder failed");
-		});
-		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 ObjectionFactory(builders, {}, trx);
-			await expect(factory.insert("user")).rejects.toThrow();
-		});
-		it("should handle seed function errors gracefully", async () => {
-			const failingSeed = async (attrs, factory$1, db$1) => {
-				throw new Error("Seed failed");
+	it$1("should handle async item functions", async ({ trx }) => {
+		const userBuilder = 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 ObjectionFactory({}, seeds, trx);
-			await expect(factory.seed("failingSeed")).rejects.toThrow("Seed failed");
 		});
+		const builders = { user: userBuilder };
+		const factory = new ObjectionFactory(builders, {}, trx);
+		const result = await factory.insert("user");
+		expect(result).toBeInstanceOf(User);
+		expect(result.name).toBe("Async User");
+		expect(result.id).toBeDefined();
 	});
-	describe("type safety and integration", () => {
-		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 ObjectionFactory(builders, seeds, trx);
-			expect(factory).toBeInstanceOf(ObjectionFactory);
-			const admin = await factory.seed("admin", { isSuper: true });
-			expect(admin).toBeInstanceOf(User);
-			expect(admin.name).toBe("Admin");
-		});
-		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$1("should work without item function", async ({ trx }) => {
+		const userBuilder = ObjectionFactory.createBuilder(User);
+		const builders = { user: userBuilder };
+		const factory = new ObjectionFactory(builders, {}, trx);
+		const attrs = { name: "Manual User" };
+		const result = await factory.insert("user", attrs);
+		expect(result).toBeInstanceOf(User);
+		expect(result.name).toBe("Manual User");
+		expect(result.id).toBeDefined();
+	});
+	it$1("should allow overriding default values", async ({ trx }) => {
+		const userBuilder = ObjectionFactory.createBuilder(User, (attrs, factory$1, db, faker$1) => ({
+			name: "Default Name",
+			...attrs
+		}));
+		const builders = { user: userBuilder };
+		const factory = new ObjectionFactory(builders, {}, trx);
+		const result = await factory.insert("user", { name: "Override Name" });
+		expect(result).toBeInstanceOf(User);
+		expect(result.name).toBe("Override Name");
+	});
+	it$1("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 ObjectionFactory(builders, {}, trx);
+		await expect(factory.insert("user")).rejects.toThrow("Builder failed");
+	});
+	it$1("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 ObjectionFactory(builders, {}, trx);
+		await expect(factory.insert("user")).rejects.toThrow();
+	});
+	it$1("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 ObjectionFactory({}, seeds, trx);
+		await expect(factory.seed("failingSeed")).rejects.toThrow("Seed failed");
+	});
+	it$1("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 ObjectionFactory(builders, seeds, trx);
+		expect(factory).toBeInstanceOf(ObjectionFactory);
+		const admin = await factory.seed("admin", { isSuper: true });
+		expect(admin).toBeInstanceOf(User);
+		expect(admin.name).toBe("Admin");
+	});
+	it$1("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 ObjectionFactory(builders, {}, trx);
-			const post = await factory.insert("post", { title: "Test Post" });
-			expect(post).toBeInstanceOf(Post);
-			expect(post.title).toBe("Test Post");
-			expect(post.userId).toBeDefined();
-			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 ObjectionFactory(builders, {}, trx);
+		const post = await factory.insert("post", { title: "Test Post" });
+		expect(post).toBeInstanceOf(Post);
+		expect(post.title).toBe("Test Post");
+		expect(post.user_id).toBeDefined();
+		expect(typeof post.user_id).toBe("string");
 	});
 });