@geekmidas/testkit 0.0.3 → 0.0.5

package/dist/__tests__/integration.spec.cjs

@@ -0,0 +1,279 @@
+const require_chunk = require('../chunk-CUT6urMc.cjs');
+require('../Factory-DREHoms3.cjs');
+require('../faker-caz-8zt8.cjs');
+const require_KyselyFactory = require('../KyselyFactory-BX7Kv2uP.cjs');
+require('../VitestTransactionIsolator-Bx2c4OzK.cjs');
+require('../VitestKyselyTransactionIsolator-DWSTKIe3.cjs');
+const require_helpers = require('../helpers-B9Jdk_C7.cjs');
+const require_helpers$1 = require('../helpers-DKEBHABj.cjs');
+const vitest = require_chunk.__toESM(require("vitest"));
+
+//#region src/__tests__/integration.spec.ts
+const db = require_helpers.createKyselyDb(require_helpers$1.TEST_DATABASE_CONFIG);
+const it = require_helpers.wrapVitestKyselyTransaction(db, require_helpers$1.createTestTables);
+(0, vitest.describe)("Testkit Integration Tests", () => {
+	(0, vitest.beforeAll)(async () => {});
+	(0, vitest.describe)("Complex Factory Scenarios", () => {
+		it("should handle complex multi-table data creation", async ({ trx }) => {
+			const userBuilder = require_KyselyFactory.KyselyFactory.createBuilder("users", async (attrs) => ({
+				name: "John Doe",
+				email: `user${Date.now()}-${Math.random()}@example.com`,
+				role: "user",
+				createdAt: /* @__PURE__ */ new Date(),
+				updatedAt: /* @__PURE__ */ new Date()
+			}));
+			const postBuilder = require_KyselyFactory.KyselyFactory.createBuilder("posts", async (attrs, factory$1) => {
+				if (!attrs.userId) {
+					const user = await factory$1.insert("user");
+					return {
+						title: "Default Post Title",
+						content: "Default post content...",
+						userId: user.id,
+						published: false,
+						createdAt: /* @__PURE__ */ new Date(),
+						updatedAt: /* @__PURE__ */ new Date()
+					};
+				}
+				return {
+					title: "Default Post Title",
+					content: "Default post content...",
+					published: false,
+					createdAt: /* @__PURE__ */ new Date(),
+					updatedAt: /* @__PURE__ */ new Date()
+				};
+			});
+			const commentBuilder = require_KyselyFactory.KyselyFactory.createBuilder("comments", async (attrs, factory$1) => {
+				let postId = attrs.postId;
+				let userId = attrs.userId;
+				if (!postId) {
+					const post = await factory$1.insert("post");
+					postId = post.id;
+				}
+				if (!userId) {
+					const user = await factory$1.insert("user");
+					userId = user.id;
+				}
+				return {
+					content: "Default comment content",
+					postId,
+					userId,
+					createdAt: /* @__PURE__ */ new Date()
+				};
+			});
+			const builders = {
+				user: userBuilder,
+				post: postBuilder,
+				comment: commentBuilder
+			};
+			const factory = new require_KyselyFactory.KyselyFactory(builders, {}, trx);
+			const author = await factory.insert("user", {
+				name: "Jane Author",
+				email: "jane@author.com",
+				role: "admin"
+			});
+			const posts = await factory.insertMany(3, "post", (idx) => ({
+				title: `Post ${idx + 1}`,
+				content: `Content for post ${idx + 1}`,
+				userId: author.id,
+				published: idx < 2
+			}));
+			const comments = await factory.insertMany(5, "comment", (idx) => ({
+				content: `Comment ${idx + 1} on first post`,
+				postId: posts[0].id
+			}));
+			(0, vitest.expect)(author.name).toBe("Jane Author");
+			(0, vitest.expect)(author.role).toBe("admin");
+			(0, vitest.expect)(posts).toHaveLength(3);
+			(0, vitest.expect)(posts[0].title).toBe("Post 1");
+			(0, vitest.expect)(posts[0].published).toBe(true);
+			(0, vitest.expect)(posts[2].published).toBe(false);
+			(0, vitest.expect)(comments).toHaveLength(5);
+			comments.forEach((comment, idx) => {
+				(0, vitest.expect)(comment.content).toBe(`Comment ${idx + 1} on first post`);
+				(0, vitest.expect)(comment.postId).toBe(posts[0].id);
+			});
+			const authorPosts = await trx.selectFrom("posts").selectAll().where("userId", "=", author.id).execute();
+			(0, vitest.expect)(authorPosts).toHaveLength(3);
+			const firstPostComments = await trx.selectFrom("comments").selectAll().where("postId", "=", posts[0].id).execute();
+			(0, vitest.expect)(firstPostComments).toHaveLength(5);
+		});
+		it("should handle seeds for complex scenarios", async ({ trx }) => {
+			const c = await trx.selectFrom("users").select(trx.fn.count("id").as("count")).executeTakeFirst();
+			const userBuilder = require_KyselyFactory.KyselyFactory.createBuilder("users", async (attrs) => ({
+				name: "Default User",
+				email: `user${Date.now()}-${Math.random()}@example.com`,
+				role: "user",
+				createdAt: /* @__PURE__ */ new Date(),
+				updatedAt: /* @__PURE__ */ new Date()
+			}));
+			const postBuilder = require_KyselyFactory.KyselyFactory.createBuilder("posts", async (attrs, factory$1) => {
+				if (!attrs.userId) {
+					const user = await factory$1.insert("user");
+					return {
+						title: "Default Post",
+						content: "Default content",
+						userId: user.id,
+						published: false,
+						createdAt: /* @__PURE__ */ new Date(),
+						updatedAt: /* @__PURE__ */ new Date()
+					};
+				}
+				return {
+					title: "Default Post",
+					content: "Default content",
+					published: false,
+					createdAt: /* @__PURE__ */ new Date(),
+					updatedAt: /* @__PURE__ */ new Date()
+				};
+			});
+			const builders = {
+				user: userBuilder,
+				post: postBuilder
+			};
+			const seeds = {
+				blogWithAdminAndPosts: require_KyselyFactory.KyselyFactory.createSeed(async (attrs, factory$1, db$1) => {
+					const admin = await factory$1.insert("user", {
+						name: "Blog Admin",
+						email: "admin@blog.com",
+						role: "admin"
+					});
+					const postCount = attrs.postCount || 3;
+					const posts = await factory$1.insertMany(postCount, "post", (idx) => ({
+						title: `Admin Post ${idx + 1}`,
+						content: `Content for admin post ${idx + 1}`,
+						userId: admin.id,
+						published: true
+					}));
+					return {
+						admin,
+						posts,
+						summary: {
+							adminId: admin.id,
+							postIds: posts.map((p) => p.id),
+							totalPosts: posts.length
+						}
+					};
+				}),
+				usersWithPosts: require_KyselyFactory.KyselyFactory.createSeed(async (attrs, factory$1, db$1) => {
+					const userCount = attrs.userCount || 2;
+					const postsPerUser = attrs.postsPerUser || 2;
+					const results = [];
+					for (let i = 0; i < userCount; i++) {
+						const user = await factory$1.insert("user", {
+							name: `User ${i + 1}`,
+							email: `user${i + 1}@example.com`
+						});
+						const posts = await factory$1.insertMany(postsPerUser, "post", (postIdx) => ({
+							title: `User ${i + 1} Post ${postIdx + 1}`,
+							content: `Content from user ${i + 1}, post ${postIdx + 1}`,
+							userId: user.id,
+							published: postIdx === 0
+						}));
+						results.push({
+							user,
+							posts
+						});
+					}
+					return results;
+				})
+			};
+			const factory = new require_KyselyFactory.KyselyFactory(builders, seeds, trx);
+			const blogData = await factory.seed("blogWithAdminAndPosts", { postCount: 5 });
+			(0, vitest.expect)(blogData.admin.name).toBe("Blog Admin");
+			(0, vitest.expect)(blogData.admin.role).toBe("admin");
+			(0, vitest.expect)(blogData.posts).toHaveLength(5);
+			(0, vitest.expect)(blogData.summary.totalPosts).toBe(5);
+			const userData = await factory.seed("usersWithPosts", {
+				userCount: 3,
+				postsPerUser: 4
+			});
+			(0, vitest.expect)(userData).toHaveLength(3);
+			const totalUsers = await trx.selectFrom("users").select(trx.fn.count("id").as("count")).executeTakeFirst();
+			const totalPosts = await trx.selectFrom("posts").select(trx.fn.count("id").as("count")).executeTakeFirst();
+			(0, vitest.expect)(Number(totalUsers?.count)).toBe(4);
+			(0, vitest.expect)(Number(totalPosts?.count)).toBe(17);
+		});
+		it("should handle transaction isolation properly", async ({ trx }) => {
+			const userBuilder = require_KyselyFactory.KyselyFactory.createBuilder("users", async (attrs, factory, db$1, faker) => ({
+				name: "Test User",
+				email: faker.internet.email(),
+				role: "user",
+				createdAt: /* @__PURE__ */ new Date(),
+				updatedAt: /* @__PURE__ */ new Date()
+			}));
+			const builders = { user: userBuilder };
+			const factory1 = new require_KyselyFactory.KyselyFactory(builders, {}, trx);
+			const user = await factory1.insert("user", {
+				name: "Transaction User",
+				email: "transaction@test.com"
+			});
+			const userInTrx = await trx.selectFrom("users").selectAll().where("id", "=", user.id).executeTakeFirst();
+			(0, vitest.expect)(userInTrx).toBeDefined();
+			(0, vitest.expect)(userInTrx?.name).toBe("Transaction User");
+		});
+	});
+	(0, vitest.describe)("Performance and Edge Cases", () => {
+		it("should handle creating many records efficiently", async ({ trx }) => {
+			const userBuilder = require_KyselyFactory.KyselyFactory.createBuilder("users", async (attrs, factory$1, db$1, faker) => ({
+				name: `User ${Math.random()}`,
+				email: faker.internet.email().toLowerCase(),
+				role: "user",
+				createdAt: /* @__PURE__ */ new Date(),
+				updatedAt: /* @__PURE__ */ new Date()
+			}));
+			const builders = { user: userBuilder };
+			const factory = new require_KyselyFactory.KyselyFactory(builders, {}, trx);
+			const startTime = Date.now();
+			const users = await factory.insertMany(100, "user");
+			const endTime = Date.now();
+			const duration = endTime - startTime;
+			(0, vitest.expect)(users).toHaveLength(100);
+			(0, vitest.expect)(duration).toBeLessThan(5e3);
+			const emails = users.map((u) => u.email);
+			const uniqueEmails = new Set(emails);
+			(0, vitest.expect)(uniqueEmails.size).toBe(100);
+		});
+		it("should handle complex attribute generation", async ({ trx }) => {
+			const userBuilder = require_KyselyFactory.KyselyFactory.createBuilder("users", async (attrs, factory$1, db$1, faker) => {
+				return {
+					name: `Generated User ${attrs.id}`,
+					email: faker.internet.email().toLowerCase(),
+					role: "user"
+				};
+			});
+			const postBuilder = require_KyselyFactory.KyselyFactory.createBuilder("posts", async (attrs, factory$1) => {
+				let userId = attrs.userId;
+				if (!userId) {
+					const user = await factory$1.insert("user");
+					userId = user.id;
+				}
+				return {
+					title: `Auto-generated Post`,
+					content: `This is auto-generated content for post. Lorem ipsum dolor sit amet.`,
+					published: true,
+					userId,
+					createdAt: /* @__PURE__ */ new Date(),
+					updatedAt: /* @__PURE__ */ new Date()
+				};
+			});
+			const builders = {
+				user: userBuilder,
+				post: postBuilder
+			};
+			const factory = new require_KyselyFactory.KyselyFactory(builders, {}, trx);
+			const posts = await factory.insertMany(10, "post", (i) => ({ published: i % 2 === 0 }));
+			(0, vitest.expect)(posts).toHaveLength(10);
+			const users = await trx.selectFrom("users").selectAll().execute();
+			users.forEach((user) => {
+				(0, vitest.expect)(user.email).toBe(user.email.toLowerCase());
+				(0, vitest.expect)(user.name).not.toMatch(/^\s|\s$/);
+			});
+			const publishedPosts = posts.filter((p) => p.published);
+			const unpublishedPosts = posts.filter((p) => !p.published);
+			(0, vitest.expect)(publishedPosts).toHaveLength(5);
+			(0, vitest.expect)(unpublishedPosts).toHaveLength(5);
+		});
+	});
+});
+
+//#endregion

package/dist/__tests__/integration.spec.mjs

@@ -0,0 +1,278 @@
+import "../Factory-DlzMkMzb.mjs";
+import "../faker-BwaXA_RF.mjs";
+import { KyselyFactory } from "../KyselyFactory-pOMOFQWE.mjs";
+import "../VitestTransactionIsolator-BjVXqFs6.mjs";
+import "../VitestKyselyTransactionIsolator-BS3R-V0I.mjs";
+import { createKyselyDb, wrapVitestKyselyTransaction } from "../helpers-DOiGIkaU.mjs";
+import { TEST_DATABASE_CONFIG, createTestTables } from "../helpers-BfuX-cjN.mjs";
+import { beforeAll, describe, expect } from "vitest";
+
+//#region src/__tests__/integration.spec.ts
+const db = createKyselyDb(TEST_DATABASE_CONFIG);
+const it$1 = wrapVitestKyselyTransaction(db, createTestTables);
+describe("Testkit Integration Tests", () => {
+	beforeAll(async () => {});
+	describe("Complex Factory Scenarios", () => {
+		it$1("should handle complex multi-table data creation", async ({ trx }) => {
+			const userBuilder = KyselyFactory.createBuilder("users", async (attrs) => ({
+				name: "John Doe",
+				email: `user${Date.now()}-${Math.random()}@example.com`,
+				role: "user",
+				createdAt: /* @__PURE__ */ new Date(),
+				updatedAt: /* @__PURE__ */ new Date()
+			}));
+			const postBuilder = KyselyFactory.createBuilder("posts", async (attrs, factory$1) => {
+				if (!attrs.userId) {
+					const user = await factory$1.insert("user");
+					return {
+						title: "Default Post Title",
+						content: "Default post content...",
+						userId: user.id,
+						published: false,
+						createdAt: /* @__PURE__ */ new Date(),
+						updatedAt: /* @__PURE__ */ new Date()
+					};
+				}
+				return {
+					title: "Default Post Title",
+					content: "Default post content...",
+					published: false,
+					createdAt: /* @__PURE__ */ new Date(),
+					updatedAt: /* @__PURE__ */ new Date()
+				};
+			});
+			const commentBuilder = KyselyFactory.createBuilder("comments", async (attrs, factory$1) => {
+				let postId = attrs.postId;
+				let userId = attrs.userId;
+				if (!postId) {
+					const post = await factory$1.insert("post");
+					postId = post.id;
+				}
+				if (!userId) {
+					const user = await factory$1.insert("user");
+					userId = user.id;
+				}
+				return {
+					content: "Default comment content",
+					postId,
+					userId,
+					createdAt: /* @__PURE__ */ new Date()
+				};
+			});
+			const builders = {
+				user: userBuilder,
+				post: postBuilder,
+				comment: commentBuilder
+			};
+			const factory = new KyselyFactory(builders, {}, trx);
+			const author = await factory.insert("user", {
+				name: "Jane Author",
+				email: "jane@author.com",
+				role: "admin"
+			});
+			const posts = await factory.insertMany(3, "post", (idx) => ({
+				title: `Post ${idx + 1}`,
+				content: `Content for post ${idx + 1}`,
+				userId: author.id,
+				published: idx < 2
+			}));
+			const comments = await factory.insertMany(5, "comment", (idx) => ({
+				content: `Comment ${idx + 1} on first post`,
+				postId: posts[0].id
+			}));
+			expect(author.name).toBe("Jane Author");
+			expect(author.role).toBe("admin");
+			expect(posts).toHaveLength(3);
+			expect(posts[0].title).toBe("Post 1");
+			expect(posts[0].published).toBe(true);
+			expect(posts[2].published).toBe(false);
+			expect(comments).toHaveLength(5);
+			comments.forEach((comment, idx) => {
+				expect(comment.content).toBe(`Comment ${idx + 1} on first post`);
+				expect(comment.postId).toBe(posts[0].id);
+			});
+			const authorPosts = await trx.selectFrom("posts").selectAll().where("userId", "=", author.id).execute();
+			expect(authorPosts).toHaveLength(3);
+			const firstPostComments = await trx.selectFrom("comments").selectAll().where("postId", "=", posts[0].id).execute();
+			expect(firstPostComments).toHaveLength(5);
+		});
+		it$1("should handle seeds for complex scenarios", async ({ trx }) => {
+			const c = await trx.selectFrom("users").select(trx.fn.count("id").as("count")).executeTakeFirst();
+			const userBuilder = KyselyFactory.createBuilder("users", async (attrs) => ({
+				name: "Default User",
+				email: `user${Date.now()}-${Math.random()}@example.com`,
+				role: "user",
+				createdAt: /* @__PURE__ */ new Date(),
+				updatedAt: /* @__PURE__ */ new Date()
+			}));
+			const postBuilder = KyselyFactory.createBuilder("posts", async (attrs, factory$1) => {
+				if (!attrs.userId) {
+					const user = await factory$1.insert("user");
+					return {
+						title: "Default Post",
+						content: "Default content",
+						userId: user.id,
+						published: false,
+						createdAt: /* @__PURE__ */ new Date(),
+						updatedAt: /* @__PURE__ */ new Date()
+					};
+				}
+				return {
+					title: "Default Post",
+					content: "Default content",
+					published: false,
+					createdAt: /* @__PURE__ */ new Date(),
+					updatedAt: /* @__PURE__ */ new Date()
+				};
+			});
+			const builders = {
+				user: userBuilder,
+				post: postBuilder
+			};
+			const seeds = {
+				blogWithAdminAndPosts: KyselyFactory.createSeed(async (attrs, factory$1, db$1) => {
+					const admin = await factory$1.insert("user", {
+						name: "Blog Admin",
+						email: "admin@blog.com",
+						role: "admin"
+					});
+					const postCount = attrs.postCount || 3;
+					const posts = await factory$1.insertMany(postCount, "post", (idx) => ({
+						title: `Admin Post ${idx + 1}`,
+						content: `Content for admin post ${idx + 1}`,
+						userId: admin.id,
+						published: true
+					}));
+					return {
+						admin,
+						posts,
+						summary: {
+							adminId: admin.id,
+							postIds: posts.map((p) => p.id),
+							totalPosts: posts.length
+						}
+					};
+				}),
+				usersWithPosts: KyselyFactory.createSeed(async (attrs, factory$1, db$1) => {
+					const userCount = attrs.userCount || 2;
+					const postsPerUser = attrs.postsPerUser || 2;
+					const results = [];
+					for (let i = 0; i < userCount; i++) {
+						const user = await factory$1.insert("user", {
+							name: `User ${i + 1}`,
+							email: `user${i + 1}@example.com`
+						});
+						const posts = await factory$1.insertMany(postsPerUser, "post", (postIdx) => ({
+							title: `User ${i + 1} Post ${postIdx + 1}`,
+							content: `Content from user ${i + 1}, post ${postIdx + 1}`,
+							userId: user.id,
+							published: postIdx === 0
+						}));
+						results.push({
+							user,
+							posts
+						});
+					}
+					return results;
+				})
+			};
+			const factory = new KyselyFactory(builders, seeds, trx);
+			const blogData = await factory.seed("blogWithAdminAndPosts", { postCount: 5 });
+			expect(blogData.admin.name).toBe("Blog Admin");
+			expect(blogData.admin.role).toBe("admin");
+			expect(blogData.posts).toHaveLength(5);
+			expect(blogData.summary.totalPosts).toBe(5);
+			const userData = await factory.seed("usersWithPosts", {
+				userCount: 3,
+				postsPerUser: 4
+			});
+			expect(userData).toHaveLength(3);
+			const totalUsers = await trx.selectFrom("users").select(trx.fn.count("id").as("count")).executeTakeFirst();
+			const totalPosts = await trx.selectFrom("posts").select(trx.fn.count("id").as("count")).executeTakeFirst();
+			expect(Number(totalUsers?.count)).toBe(4);
+			expect(Number(totalPosts?.count)).toBe(17);
+		});
+		it$1("should handle transaction isolation properly", async ({ trx }) => {
+			const userBuilder = KyselyFactory.createBuilder("users", async (attrs, factory, db$1, faker) => ({
+				name: "Test User",
+				email: faker.internet.email(),
+				role: "user",
+				createdAt: /* @__PURE__ */ new Date(),
+				updatedAt: /* @__PURE__ */ new Date()
+			}));
+			const builders = { user: userBuilder };
+			const factory1 = new KyselyFactory(builders, {}, trx);
+			const user = await factory1.insert("user", {
+				name: "Transaction User",
+				email: "transaction@test.com"
+			});
+			const userInTrx = await trx.selectFrom("users").selectAll().where("id", "=", user.id).executeTakeFirst();
+			expect(userInTrx).toBeDefined();
+			expect(userInTrx?.name).toBe("Transaction User");
+		});
+	});
+	describe("Performance and Edge Cases", () => {
+		it$1("should handle creating many records efficiently", async ({ trx }) => {
+			const userBuilder = KyselyFactory.createBuilder("users", async (attrs, factory$1, db$1, faker) => ({
+				name: `User ${Math.random()}`,
+				email: faker.internet.email().toLowerCase(),
+				role: "user",
+				createdAt: /* @__PURE__ */ new Date(),
+				updatedAt: /* @__PURE__ */ new Date()
+			}));
+			const builders = { user: userBuilder };
+			const factory = new KyselyFactory(builders, {}, trx);
+			const startTime = Date.now();
+			const users = await factory.insertMany(100, "user");
+			const endTime = Date.now();
+			const duration = endTime - startTime;
+			expect(users).toHaveLength(100);
+			expect(duration).toBeLessThan(5e3);
+			const emails = users.map((u) => u.email);
+			const uniqueEmails = new Set(emails);
+			expect(uniqueEmails.size).toBe(100);
+		});
+		it$1("should handle complex attribute generation", async ({ trx }) => {
+			const userBuilder = KyselyFactory.createBuilder("users", async (attrs, factory$1, db$1, faker) => {
+				return {
+					name: `Generated User ${attrs.id}`,
+					email: faker.internet.email().toLowerCase(),
+					role: "user"
+				};
+			});
+			const postBuilder = KyselyFactory.createBuilder("posts", async (attrs, factory$1) => {
+				let userId = attrs.userId;
+				if (!userId) {
+					const user = await factory$1.insert("user");
+					userId = user.id;
+				}
+				return {
+					title: `Auto-generated Post`,
+					content: `This is auto-generated content for post. Lorem ipsum dolor sit amet.`,
+					published: true,
+					userId,
+					createdAt: /* @__PURE__ */ new Date(),
+					updatedAt: /* @__PURE__ */ new Date()
+				};
+			});
+			const builders = {
+				user: userBuilder,
+				post: postBuilder
+			};
+			const factory = new KyselyFactory(builders, {}, trx);
+			const posts = await factory.insertMany(10, "post", (i) => ({ published: i % 2 === 0 }));
+			expect(posts).toHaveLength(10);
+			const users = await trx.selectFrom("users").selectAll().execute();
+			users.forEach((user) => {
+				expect(user.email).toBe(user.email.toLowerCase());
+				expect(user.name).not.toMatch(/^\s|\s$/);
+			});
+			const publishedPosts = posts.filter((p) => p.published);
+			const unpublishedPosts = posts.filter((p) => !p.published);
+			expect(publishedPosts).toHaveLength(5);
+			expect(unpublishedPosts).toHaveLength(5);
+		});
+	});
+});
+
+//#endregion

package/dist/chunk-CUT6urMc.cjs

@@ -0,0 +1,30 @@
+//#region rolldown:runtime
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
+
+Object.defineProperty(exports, '__toESM', {
+  enumerable: true,
+  get: function () {
+    return __toESM;
+  }
+});

package/dist/example.cjs

@@ -1,5 +1,6 @@
 require('./Factory-DREHoms3.cjs');
-const require_KyselyFactory = require('./KyselyFactory-DiiWtMYe.cjs');
+require('./faker-caz-8zt8.cjs');
+const require_KyselyFactory = require('./KyselyFactory-BX7Kv2uP.cjs');
 
 //#region src/example.ts
 const userBuilder = require_KyselyFactory.KyselyFactory.createBuilder({

package/dist/example.mjs

@@ -1,5 +1,6 @@
 import "./Factory-DlzMkMzb.mjs";
-import { KyselyFactory } from "./KyselyFactory-DZewtWtJ.mjs";
+import "./faker-BwaXA_RF.mjs";
+import { KyselyFactory } from "./KyselyFactory-pOMOFQWE.mjs";
 
 //#region src/example.ts
 const userBuilder = KyselyFactory.createBuilder({

package/dist/faker-BwaXA_RF.mjs

@@ -0,0 +1,85 @@
+import { faker } from "@faker-js/faker";
+
+//#region src/faker.ts
+/**
+* Atomic counter implementation for thread-safe sequence generation
+*/
+var AtomicCounter = class {
+	value;
+	constructor(initialValue = 0) {
+		this.value = initialValue;
+	}
+	increment() {
+		return ++this.value;
+	}
+	get() {
+		return this.value;
+	}
+	reset(value = 0) {
+		this.value = value;
+	}
+};
+/**
+* Sets the `insertedAt` and `updatedAt` to a random date in the past.
+*/
+function timestamps() {
+	const createdAt = faker$1.date.past();
+	const updatedAt = faker$1.date.between({
+		from: createdAt,
+		to: /* @__PURE__ */ new Date()
+	});
+	createdAt.setMilliseconds(0);
+	updatedAt.setMilliseconds(0);
+	return {
+		createdAt,
+		updatedAt
+	};
+}
+/**
+* Returns a reverse domain name identifier.
+*/
+function identifier(suffix) {
+	return [
+		faker$1.internet.domainSuffix(),
+		faker$1.internet.domainWord(),
+		suffix ? suffix : faker$1.internet.domainWord() + sequence("identifier")
+	].join(".");
+}
+const sequences = /* @__PURE__ */ new Map();
+function sequence(name = "default") {
+	if (!sequences.has(name)) sequences.set(name, new AtomicCounter());
+	const counter = sequences.get(name);
+	return counter.increment();
+}
+/**
+* Resets a sequence counter to a specific value (default: 0)
+*/
+function resetSequence(name = "default", value = 0) {
+	if (sequences.has(name)) {
+		const counter = sequences.get(name);
+		counter.reset(value);
+	} else sequences.set(name, new AtomicCounter(value));
+}
+/**
+* Resets all sequence counters
+*/
+function resetAllSequences() {
+	sequences.clear();
+}
+/**
+* Returns a random price number.
+*/
+function price() {
+	return +faker$1.commerce.price();
+}
+const faker$1 = Object.freeze(Object.assign({}, faker, {
+	timestamps,
+	identifier,
+	sequence,
+	resetSequence,
+	resetAllSequences,
+	price
+}));
+
+//#endregion
+export { faker$1 as faker, identifier, resetAllSequences, resetSequence, sequence, timestamps };