@geekmidas/testkit 0.0.4 → 0.0.6

package/dist/__tests__/KyselyFactory.spec.cjs

@@ -1,60 +1,60 @@
-const require_chunk = require('../chunk-DWy1uDak.cjs');
+const require_chunk = require('../chunk-CUT6urMc.cjs');
 require('../Factory-DREHoms3.cjs');
-require('../faker-h6CkRloU.cjs');
-const require_KyselyFactory = require('../KyselyFactory-BGvSMLtd.cjs');
-const require_dist = require('../dist-DE3gAxQI.cjs');
-const require_vi_bdSIJ99Y = require('../vi.bdSIJ99Y-CFuzUeY6.cjs');
-require('../VitestTransactionIsolator-zK5NJ7DQ.cjs');
-require('../VitestKyselyTransactionIsolator-Dh2AgJDd.cjs');
-const require_helpers = require('../helpers-C_RZk04R.cjs');
-const require_helpers$1 = require('../helpers-C2NH7xcz.cjs');
+require('../faker-caz-8zt8.cjs');
+const require_KyselyFactory = require('../KyselyFactory-BX7Kv2uP.cjs');
+require('../PostgresMigrator-Bz-tnjB6.cjs');
+require('../PostgresKyselyMigrator-JTY2LfwD.cjs');
+require('../VitestTransactionIsolator-BK9UsrKt.cjs');
+require('../VitestKyselyTransactionIsolator-jF6Ohyu_.cjs');
+const require_helpers = require('../helpers-DOtYCEvZ.cjs');
+const require_kysely = require('../kysely-DL3C2eM4.cjs');
+const require_helpers$1 = require('../helpers-B2CfbaTC.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_helpers.wrapVitestKyselyTransaction(db, require_helpers$1.createTestTables);
+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);
 });
-require_dist.describe("KyselyFactory", () => {
-	let db$1;
-	let trx;
-	require_dist.describe("KyselyFactory.insert", () => {
-		itWithTransaction("should insert a record with defaults", async ({ trx: trx$1 }) => {
+(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$1);
+			const factory = new require_KyselyFactory.KyselyFactory(builders, {}, trx);
 			const user = await factory.insert("user");
-			require_vi_bdSIJ99Y.globalExpect(user).toBeDefined();
-			require_vi_bdSIJ99Y.globalExpect(user.id).toBeDefined();
-			require_vi_bdSIJ99Y.globalExpect(user.name).toBe("John Doe");
-			require_vi_bdSIJ99Y.globalExpect(user.email).toContain("user");
-			require_vi_bdSIJ99Y.globalExpect(user.email).toContain("@example.com");
-			require_vi_bdSIJ99Y.globalExpect(user.createdAt).toBeInstanceOf(Date);
+			(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: trx$1 }) => {
+		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$1);
+			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
 			});
-			require_vi_bdSIJ99Y.globalExpect(user.name).toBe(customName);
-			require_vi_bdSIJ99Y.globalExpect(user.email).toBe(customEmail);
+			(0, vitest.expect)(user.name).toBe(customName);
+			(0, vitest.expect)(user.email).toBe(customEmail);
 		});
-		itWithTransaction("should handle relations", async ({ trx: trx$1 }) => {
+		itWithTransaction("should handle relations", async ({ trx }) => {
 			const userBuilder = require_KyselyFactory.KyselyFactory.createBuilder("users", async (attrs) => ({
 				name: "John Doe",
 				email: `user${Date.now()}@example.com`,
@@ -80,55 +80,55 @@ require_dist.describe("KyselyFactory", () => {
 				user: userBuilder,
 				post: postBuilder
 			};
-			const factory = new require_KyselyFactory.KyselyFactory(builders, {}, trx$1);
+			const factory = new require_KyselyFactory.KyselyFactory(builders, {}, trx);
 			const post = await factory.insert("post", { title: "Test Post" });
-			require_vi_bdSIJ99Y.globalExpect(post).toBeDefined();
-			require_vi_bdSIJ99Y.globalExpect(post.title).toBe("Test Post");
-			require_vi_bdSIJ99Y.globalExpect(post.userId).toBeDefined();
-			require_vi_bdSIJ99Y.globalExpect(typeof post.userId).toBe("number");
+			(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: trx$1 }) => {
-			const factory = new require_KyselyFactory.KyselyFactory({}, {}, trx$1);
-			await require_vi_bdSIJ99Y.globalExpect(factory.insert("nonExistent")).rejects.toThrow("Factory \"nonExistent\" does not exist");
+		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");
 		});
 	});
-	require_dist.describe("KyselyFactory.insertMany", () => {
-		itWithTransaction("should insert multiple records with same attributes", async ({ trx: trx$1 }) => {
+	(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$1);
+			const factory = new require_KyselyFactory.KyselyFactory(builders, {}, trx);
 			const users = await factory.insertMany(3, "user");
-			require_vi_bdSIJ99Y.globalExpect(users).toHaveLength(3);
+			(0, vitest.expect)(users).toHaveLength(3);
 			users.forEach((user, index) => {
-				require_vi_bdSIJ99Y.globalExpect(user.id).toBeDefined();
-				require_vi_bdSIJ99Y.globalExpect(user.name).toBe("John Doe");
-				require_vi_bdSIJ99Y.globalExpect(user.email).toContain("@example.com");
+				(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: trx$1 }) => {
+		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$1);
+			const factory = new require_KyselyFactory.KyselyFactory(builders, {}, trx);
 			const users = await factory.insertMany(3, "user", (idx) => ({ name: `User ${idx}` }));
-			require_vi_bdSIJ99Y.globalExpect(users).toHaveLength(3);
+			(0, vitest.expect)(users).toHaveLength(3);
 			users.forEach((user, index) => {
-				require_vi_bdSIJ99Y.globalExpect(user.name).toBe(`User ${index}`);
+				(0, vitest.expect)(user.name).toBe(`User ${index}`);
 			});
 		});
-		itWithTransaction("should throw error for non-existent builder", async ({ trx: trx$1 }) => {
-			const factory = new require_KyselyFactory.KyselyFactory({}, {}, trx$1);
-			await require_vi_bdSIJ99Y.globalExpect(factory.insertMany(2, "nonExistent")).rejects.toThrow("Builder \"nonExistent\" is not registered");
+		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");
 		});
 	});
-	require_dist.describe("KyselyFactory.createBuilder", () => {
-		itWithTransaction("should work with async defaults", async ({ trx: trx$1 }) => {
+	(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));
@@ -140,71 +140,71 @@ require_dist.describe("KyselyFactory", () => {
 				};
 			});
 			const builders = { user: userBuilder };
-			const factory = new require_KyselyFactory.KyselyFactory(builders, {}, trx$1);
+			const factory = new require_KyselyFactory.KyselyFactory(builders, {}, trx);
 			const user1 = await factory.insert("user");
 			const user2 = await factory.insert("user");
-			require_vi_bdSIJ99Y.globalExpect(user1.name).toBe("Async User 1");
-			require_vi_bdSIJ99Y.globalExpect(user2.name).toBe("Async User 2");
+			(0, vitest.expect)(user1.name).toBe("Async User 1");
+			(0, vitest.expect)(user2.name).toBe("Async User 2");
 		});
 	});
-	require_dist.describe("KyselyFactory.seed", () => {
-		itWithTransaction("should execute seed functions", async ({ trx: trx$1 }) => {
+	(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$2) => {
+			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$1);
+			const factory = new require_KyselyFactory.KyselyFactory(builders, seeds, trx);
 			const adminUser = await factory.seed("createAdminUser");
-			require_vi_bdSIJ99Y.globalExpect(adminUser).toBeDefined();
-			require_vi_bdSIJ99Y.globalExpect(adminUser.name).toBe("Admin User");
-			require_vi_bdSIJ99Y.globalExpect(adminUser.email).toBe("admin@example.com");
+			(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: trx$1 }) => {
+		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$2) => {
+			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$1);
+			const factory = new require_KyselyFactory.KyselyFactory(builders, seeds, trx);
 			const customUser = await factory.seed("createCustomUser", {
 				name: "Custom User",
 				email: "custom@test.com"
 			});
-			require_vi_bdSIJ99Y.globalExpect(customUser.name).toBe("Custom User");
-			require_vi_bdSIJ99Y.globalExpect(customUser.email).toBe("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: trx$1 }) => {
-			const factory = new require_KyselyFactory.KyselyFactory({}, {}, trx$1);
-			require_vi_bdSIJ99Y.globalExpect(() => factory.seed("nonExistent")).toThrow("Seed \"nonExistent\" is not registered");
+		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");
 		});
 	});
-	require_dist.describe("Factory integration", () => {
-		itWithTransaction("should work with controlled transactions", async ({ trx: trx$1 }) => {
+	(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$1);
+			const factory = new require_KyselyFactory.KyselyFactory(builders, {}, trx);
 			const user = await factory.insert("user");
-			const foundUser = await trx$1.selectFrom("users").selectAll().where("id", "=", user.id).executeTakeFirst();
-			require_vi_bdSIJ99Y.globalExpect(foundUser).toBeDefined();
-			require_vi_bdSIJ99Y.globalExpect(foundUser?.id).toBe(user.id);
+			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: trx$1 }) => {
+		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`,
@@ -223,11 +223,11 @@ require_dist.describe("KyselyFactory", () => {
 				user: userBuilder,
 				post: postBuilder
 			};
-			const factory = new require_KyselyFactory.KyselyFactory(builders, {}, trx$1);
+			const factory = new require_KyselyFactory.KyselyFactory(builders, {}, trx);
 			const post = await factory.insert("post");
-			require_vi_bdSIJ99Y.globalExpect(post.userId).toBeDefined();
-			const relatedUser = await trx$1.selectFrom("users").selectAll().where("id", "=", post.userId).executeTakeFirst();
-			require_vi_bdSIJ99Y.globalExpect(relatedUser).toBeDefined();
+			(0, vitest.expect)(post.userId).toBeDefined();
+			const relatedUser = await trx.selectFrom("users").selectAll().where("id", "=", post.userId).executeTakeFirst();
+			(0, vitest.expect)(relatedUser).toBeDefined();
 		});
 	});
 });

package/dist/__tests__/KyselyFactory.spec.mjs

@@ -1,59 +1,59 @@
-import { describe } from "../dist-BM2KvLG1.mjs";
-import "../Factory-D52Lsc6Z.mjs";
-import "../faker-cGCFcrj2.mjs";
-import { KyselyFactory } from "../KyselyFactory-ionH4gvk.mjs";
-import { globalExpect } from "../vi.bdSIJ99Y-BgRxGeO2.mjs";
-import "../VitestTransactionIsolator-pLwsDo_A.mjs";
-import "../VitestKyselyTransactionIsolator-DXjWQtDN.mjs";
-import { createKyselyDb, wrapVitestKyselyTransaction } from "../helpers-BnARb5Ap.mjs";
-import { TEST_DATABASE_CONFIG, createTestTables } from "../helpers-CukcFAU9.mjs";
+import "../Factory-DlzMkMzb.mjs";
+import "../faker-BwaXA_RF.mjs";
+import { KyselyFactory } from "../KyselyFactory-pOMOFQWE.mjs";
+import "../PostgresMigrator-CEoRKTdq.mjs";
+import "../PostgresKyselyMigrator-D8fm35-s.mjs";
+import "../VitestTransactionIsolator-e-R3p_X8.mjs";
+import "../VitestKyselyTransactionIsolator-D-qpeVKO.mjs";
+import { createKyselyDb } from "../helpers-DN4sJO4i.mjs";
+import { wrapVitestKyselyTransaction } from "../kysely-C1-aHdnU.mjs";
+import { TEST_DATABASE_CONFIG, createTestTables } from "../helpers-Rf5F71r9.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(db, createTestTables);
+const itWithTransaction = wrapVitestKyselyTransaction(it, db, createTestTables);
 const int8TypeId = 20;
 pg.types.setTypeParser(int8TypeId, (val) => {
 	return parseInt(val, 10);
 });
 describe("KyselyFactory", () => {
-	let db$1;
-	let trx;
 	describe("KyselyFactory.insert", () => {
-		itWithTransaction("should insert a record with defaults", async ({ trx: trx$1 }) => {
+		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$1);
+			const factory = new KyselyFactory(builders, {}, trx);
 			const user = await factory.insert("user");
-			globalExpect(user).toBeDefined();
-			globalExpect(user.id).toBeDefined();
-			globalExpect(user.name).toBe("John Doe");
-			globalExpect(user.email).toContain("user");
-			globalExpect(user.email).toContain("@example.com");
-			globalExpect(user.createdAt).toBeInstanceOf(Date);
+			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: trx$1 }) => {
+		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$1);
+			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
 			});
-			globalExpect(user.name).toBe(customName);
-			globalExpect(user.email).toBe(customEmail);
+			expect(user.name).toBe(customName);
+			expect(user.email).toBe(customEmail);
 		});
-		itWithTransaction("should handle relations", async ({ trx: trx$1 }) => {
+		itWithTransaction("should handle relations", async ({ trx }) => {
 			const userBuilder = KyselyFactory.createBuilder("users", async (attrs) => ({
 				name: "John Doe",
 				email: `user${Date.now()}@example.com`,
@@ -79,55 +79,55 @@ describe("KyselyFactory", () => {
 				user: userBuilder,
 				post: postBuilder
 			};
-			const factory = new KyselyFactory(builders, {}, trx$1);
+			const factory = new KyselyFactory(builders, {}, trx);
 			const post = await factory.insert("post", { title: "Test Post" });
-			globalExpect(post).toBeDefined();
-			globalExpect(post.title).toBe("Test Post");
-			globalExpect(post.userId).toBeDefined();
-			globalExpect(typeof post.userId).toBe("number");
+			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: trx$1 }) => {
-			const factory = new KyselyFactory({}, {}, trx$1);
-			await globalExpect(factory.insert("nonExistent")).rejects.toThrow("Factory \"nonExistent\" does not exist");
+		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: trx$1 }) => {
+		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$1);
+			const factory = new KyselyFactory(builders, {}, trx);
 			const users = await factory.insertMany(3, "user");
-			globalExpect(users).toHaveLength(3);
+			expect(users).toHaveLength(3);
 			users.forEach((user, index) => {
-				globalExpect(user.id).toBeDefined();
-				globalExpect(user.name).toBe("John Doe");
-				globalExpect(user.email).toContain("@example.com");
+				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: trx$1 }) => {
+		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$1);
+			const factory = new KyselyFactory(builders, {}, trx);
 			const users = await factory.insertMany(3, "user", (idx) => ({ name: `User ${idx}` }));
-			globalExpect(users).toHaveLength(3);
+			expect(users).toHaveLength(3);
 			users.forEach((user, index) => {
-				globalExpect(user.name).toBe(`User ${index}`);
+				expect(user.name).toBe(`User ${index}`);
 			});
 		});
-		itWithTransaction("should throw error for non-existent builder", async ({ trx: trx$1 }) => {
-			const factory = new KyselyFactory({}, {}, trx$1);
-			await globalExpect(factory.insertMany(2, "nonExistent")).rejects.toThrow("Builder \"nonExistent\" is not registered");
+		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: trx$1 }) => {
+		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));
@@ -139,71 +139,71 @@ describe("KyselyFactory", () => {
 				};
 			});
 			const builders = { user: userBuilder };
-			const factory = new KyselyFactory(builders, {}, trx$1);
+			const factory = new KyselyFactory(builders, {}, trx);
 			const user1 = await factory.insert("user");
 			const user2 = await factory.insert("user");
-			globalExpect(user1.name).toBe("Async User 1");
-			globalExpect(user2.name).toBe("Async User 2");
+			expect(user1.name).toBe("Async User 1");
+			expect(user2.name).toBe("Async User 2");
 		});
 	});
 	describe("KyselyFactory.seed", () => {
-		itWithTransaction("should execute seed functions", async ({ trx: trx$1 }) => {
+		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$2) => {
+			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$1);
+			const factory = new KyselyFactory(builders, seeds, trx);
 			const adminUser = await factory.seed("createAdminUser");
-			globalExpect(adminUser).toBeDefined();
-			globalExpect(adminUser.name).toBe("Admin User");
-			globalExpect(adminUser.email).toBe("admin@example.com");
+			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: trx$1 }) => {
+		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$2) => {
+			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$1);
+			const factory = new KyselyFactory(builders, seeds, trx);
 			const customUser = await factory.seed("createCustomUser", {
 				name: "Custom User",
 				email: "custom@test.com"
 			});
-			globalExpect(customUser.name).toBe("Custom User");
-			globalExpect(customUser.email).toBe("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: trx$1 }) => {
-			const factory = new KyselyFactory({}, {}, trx$1);
-			globalExpect(() => factory.seed("nonExistent")).toThrow("Seed \"nonExistent\" is not registered");
+		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: trx$1 }) => {
+		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$1);
+			const factory = new KyselyFactory(builders, {}, trx);
 			const user = await factory.insert("user");
-			const foundUser = await trx$1.selectFrom("users").selectAll().where("id", "=", user.id).executeTakeFirst();
-			globalExpect(foundUser).toBeDefined();
-			globalExpect(foundUser?.id).toBe(user.id);
+			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: trx$1 }) => {
+		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`,
@@ -222,11 +222,11 @@ describe("KyselyFactory", () => {
 				user: userBuilder,
 				post: postBuilder
 			};
-			const factory = new KyselyFactory(builders, {}, trx$1);
+			const factory = new KyselyFactory(builders, {}, trx);
 			const post = await factory.insert("post");
-			globalExpect(post.userId).toBeDefined();
-			const relatedUser = await trx$1.selectFrom("users").selectAll().where("id", "=", post.userId).executeTakeFirst();
-			globalExpect(relatedUser).toBeDefined();
+			expect(post.userId).toBeDefined();
+			const relatedUser = await trx.selectFrom("users").selectAll().where("id", "=", post.userId).executeTakeFirst();
+			expect(relatedUser).toBeDefined();
 		});
 	});
 });