@geekmidas/testkit 0.0.5 → 0.0.7

package/dist/__tests__/KyselyFactory.spec.mjs

@@ -1,32 +1,33 @@
-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 "../Factory-z2m01hMj.mjs";
+import "../faker-CxKkEeYi.mjs";
+import { KyselyFactory } from "../KyselyFactory-ELiHgHVv.mjs";
+import "../PostgresMigrator-BzqksJcW.mjs";
+import "../PostgresKyselyMigrator-ChIpZFYB.mjs";
+import "../VitestTransactionIsolator-kFL36T8x.mjs";
+import "../VitestKyselyTransactionIsolator-AfxPJEwR.mjs";
+import { createKyselyDb } from "../helpers-CKMlwSYT.mjs";
+import { wrapVitestKyselyTransaction } from "../kysely-CqfoKVXs.mjs";
+import { TEST_DATABASE_CONFIG, createTestTables } from "../helpers-CukcFAU9.mjs";
 import pg from "pg";
-import { describe, expect } from "vitest";
+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");
 			expect(user).toBeDefined();
 			expect(user.id).toBeDefined();
@@ -35,14 +36,14 @@ describe("KyselyFactory", () => {
 			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", {
@@ -52,7 +53,7 @@ describe("KyselyFactory", () => {
 			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`,
@@ -78,27 +79,27 @@ 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" });
 			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);
+		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");
 			expect(users).toHaveLength(3);
 			users.forEach((user, index) => {
@@ -107,26 +108,26 @@ describe("KyselyFactory", () => {
 				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}` }));
 			expect(users).toHaveLength(3);
 			users.forEach((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);
+		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));
@@ -138,7 +139,7 @@ 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");
 			expect(user1.name).toBe("Async User 1");
@@ -146,36 +147,36 @@ describe("KyselyFactory", () => {
 		});
 	});
 	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");
 			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"
@@ -183,26 +184,26 @@ describe("KyselyFactory", () => {
 			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);
+		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();
+			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`,
@@ -221,10 +222,10 @@ 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");
 			expect(post.userId).toBeDefined();
-			const relatedUser = await trx$1.selectFrom("users").selectAll().where("id", "=", post.userId).executeTakeFirst();
+			const relatedUser = await trx.selectFrom("users").selectAll().where("id", "=", post.userId).executeTakeFirst();
 			expect(relatedUser).toBeDefined();
 		});
 	});

package/dist/__tests__/ObjectionFactory.spec.cjs

@@ -1,7 +1,7 @@
 const require_chunk = require('../chunk-CUT6urMc.cjs');
-require('../Factory-DREHoms3.cjs');
-const require_ObjectionFactory = require('../ObjectionFactory-BlkzSEqo.cjs');
-const require_helpers = require('../helpers-DKEBHABj.cjs');
+require('../Factory-WMhTNZ9S.cjs');
+const require_ObjectionFactory = require('../ObjectionFactory-C47B03Ot.cjs');
+const require_helpers = require('../helpers-Bnm3Jy9X.cjs');
 const vitest = require_chunk.__toESM(require("vitest"));
 const objection = require_chunk.__toESM(require("objection"));
 

package/dist/__tests__/ObjectionFactory.spec.mjs

@@ -1,6 +1,6 @@
-import "../Factory-DlzMkMzb.mjs";
-import { ObjectionFactory } from "../ObjectionFactory-ChuX8sZN.mjs";
-import { setupKnexTest } from "../helpers-BfuX-cjN.mjs";
+import "../Factory-z2m01hMj.mjs";
+import { ObjectionFactory } from "../ObjectionFactory-89p-FFEw.mjs";
+import { setupKnexTest } from "../helpers-CukcFAU9.mjs";
 import { afterAll, beforeAll, describe, expect, it } from "vitest";
 import { Model } from "objection";
 

package/dist/__tests__/PostgresMigrator.spec.cjs

@@ -1,6 +1,6 @@
 const require_chunk = require('../chunk-CUT6urMc.cjs');
-const require_PostgresMigrator = require('../PostgresMigrator-Bz-tnjB6.cjs');
-const require_helpers = require('../helpers-DKEBHABj.cjs');
+const require_PostgresMigrator = require('../PostgresMigrator-BtAWdLss.cjs');
+const require_helpers = require('../helpers-Bnm3Jy9X.cjs');
 const pg = require_chunk.__toESM(require("pg"));
 const vitest = require_chunk.__toESM(require("vitest"));
 

package/dist/__tests__/PostgresMigrator.spec.mjs

@@ -1,5 +1,5 @@
-import { PostgresMigrator } from "../PostgresMigrator-CEoRKTdq.mjs";
-import { createTestDatabase } from "../helpers-BfuX-cjN.mjs";
+import { PostgresMigrator } from "../PostgresMigrator-BzqksJcW.mjs";
+import { createTestDatabase } from "../helpers-CukcFAU9.mjs";
 import { Client } from "pg";
 import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, it, vi } from "vitest";
 

package/dist/__tests__/faker.spec.cjs

@@ -1,5 +1,5 @@
 const require_chunk = require('../chunk-CUT6urMc.cjs');
-const require_faker = require('../faker-caz-8zt8.cjs');
+const require_faker = require('../faker-SMN4ira4.cjs');
 const vitest = require_chunk.__toESM(require("vitest"));
 
 //#region src/__tests__/faker.spec.ts

package/dist/__tests__/faker.spec.mjs

@@ -1,4 +1,4 @@
-import { faker } from "../faker-BwaXA_RF.mjs";
+import { faker } from "../faker-CxKkEeYi.mjs";
 import { beforeEach, describe, expect, it } from "vitest";
 
 //#region src/__tests__/faker.spec.ts

package/dist/__tests__/integration.spec.cjs

@@ -1,16 +1,19 @@
 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');
+require('../Factory-WMhTNZ9S.cjs');
+require('../faker-SMN4ira4.cjs');
+const require_KyselyFactory = require('../KyselyFactory-Bdq1s1Go.cjs');
+require('../PostgresMigrator-BtAWdLss.cjs');
+require('../PostgresKyselyMigrator-Bs31emFd.cjs');
+require('../VitestTransactionIsolator-DcOz0LZF.cjs');
+require('../VitestKyselyTransactionIsolator-YWnSJiIH.cjs');
+const require_helpers = require('../helpers-H4hO5SZR.cjs');
+const require_kysely = require('../kysely-B-GOhABm.cjs');
+const require_helpers$1 = require('../helpers-Bnm3Jy9X.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);
+const it = require_kysely.wrapVitestKyselyTransaction(vitest.it, db, require_helpers$1.createTestTables);
 (0, vitest.describe)("Testkit Integration Tests", () => {
 	(0, vitest.beforeAll)(async () => {});
 	(0, vitest.describe)("Complex Factory Scenarios", () => {

package/dist/__tests__/integration.spec.mjs

@@ -1,15 +1,18 @@
-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";
+import "../Factory-z2m01hMj.mjs";
+import "../faker-CxKkEeYi.mjs";
+import { KyselyFactory } from "../KyselyFactory-ELiHgHVv.mjs";
+import "../PostgresMigrator-BzqksJcW.mjs";
+import "../PostgresKyselyMigrator-ChIpZFYB.mjs";
+import "../VitestTransactionIsolator-kFL36T8x.mjs";
+import "../VitestKyselyTransactionIsolator-AfxPJEwR.mjs";
+import { createKyselyDb } from "../helpers-CKMlwSYT.mjs";
+import { wrapVitestKyselyTransaction } from "../kysely-CqfoKVXs.mjs";
+import { TEST_DATABASE_CONFIG, createTestTables } from "../helpers-CukcFAU9.mjs";
+import { beforeAll, describe, expect, it } from "vitest";
 
 //#region src/__tests__/integration.spec.ts
 const db = createKyselyDb(TEST_DATABASE_CONFIG);
-const it$1 = wrapVitestKyselyTransaction(db, createTestTables);
+const it$1 = wrapVitestKyselyTransaction(it, db, createTestTables);
 describe("Testkit Integration Tests", () => {
 	beforeAll(async () => {});
 	describe("Complex Factory Scenarios", () => {

package/dist/example.cjs

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

package/dist/example.mjs

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

package/dist/faker-CxKkEeYi.mjs

@@ -0,0 +1,227 @@
+import { faker } from "@faker-js/faker";
+
+//#region src/faker.ts
+/**
+* Atomic counter implementation for thread-safe sequence generation.
+* Provides a clean abstraction for generating sequential numbers in tests.
+* While JavaScript is single-threaded, this class makes the intent explicit.
+*
+* @example
+* ```typescript
+* const counter = new AtomicCounter(100);
+* console.log(counter.increment()); // 101
+* console.log(counter.increment()); // 102
+* console.log(counter.get()); // 102
+* counter.reset(200);
+* console.log(counter.increment()); // 201
+* ```
+*/
+var AtomicCounter = class {
+	/**
+	* The current counter value.
+	* @private
+	*/
+	value;
+	/**
+	* Creates a new atomic counter.
+	* @param initialValue - The starting value (default: 0)
+	*/
+	constructor(initialValue = 0) {
+		this.value = initialValue;
+	}
+	/**
+	* Increments the counter and returns the new value.
+	* @returns The incremented value
+	*/
+	increment() {
+		return ++this.value;
+	}
+	/**
+	* Gets the current counter value without incrementing.
+	* @returns The current value
+	*/
+	get() {
+		return this.value;
+	}
+	/**
+	* Resets the counter to a specific value.
+	* @param value - The new value (default: 0)
+	*/
+	reset(value = 0) {
+		this.value = value;
+	}
+};
+/**
+* Generates random timestamp fields for database records.
+* Creates a createdAt date in the past and an updatedAt date between creation and now.
+* Milliseconds are set to 0 for cleaner database storage.
+*
+* @returns Object with createdAt and updatedAt Date fields
+*
+* @example
+* ```typescript
+* const { createdAt, updatedAt } = timestamps();
+* console.log(createdAt); // 2023-05-15T10:30:00.000Z
+* console.log(updatedAt); // 2023-11-20T14:45:00.000Z
+*
+* // Use in factory
+* const user = {
+*   name: 'John Doe',
+*   ...timestamps()
+* };
+* ```
+*/
+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
+	};
+}
+/**
+* Generates a reverse domain name identifier.
+* Useful for creating unique identifiers that follow domain naming conventions.
+*
+* @param suffix - Optional suffix to append to the identifier
+* @returns A reverse domain name string (e.g., "com.example.feature123")
+*
+* @example
+* ```typescript
+* console.log(identifier()); // "com.example.widget1"
+* console.log(identifier('user')); // "org.acme.user"
+* console.log(identifier('api')); // "net.demo.api"
+* ```
+*/
+function identifier(suffix) {
+	return [
+		faker$1.internet.domainSuffix(),
+		faker$1.internet.domainWord(),
+		suffix ? suffix : faker$1.internet.domainWord() + sequence("identifier")
+	].join(".");
+}
+/**
+* Storage for named sequence counters.
+* Each sequence maintains its own independent counter.
+* @private
+*/
+const sequences = /* @__PURE__ */ new Map();
+/**
+* Generates sequential numbers for a named sequence.
+* Useful for creating unique IDs or numbered test data.
+* Each named sequence maintains its own counter.
+*
+* @param name - The sequence name (default: 'default')
+* @returns The next number in the sequence
+*
+* @example
+* ```typescript
+* console.log(sequence()); // 1
+* console.log(sequence()); // 2
+* console.log(sequence('user')); // 1
+* console.log(sequence('user')); // 2
+* console.log(sequence()); // 3
+*
+* // Use in factories
+* const email = `user${sequence('email')}@example.com`;
+* ```
+*/
+function sequence(name = "default") {
+	if (!sequences.has(name)) sequences.set(name, new AtomicCounter());
+	const counter = sequences.get(name);
+	return counter.increment();
+}
+/**
+* Resets a named sequence counter to a specific value.
+* Useful for resetting sequences between test suites.
+*
+* @param name - The sequence name to reset (default: 'default')
+* @param value - The new starting value (default: 0)
+*
+* @example
+* ```typescript
+* sequence('user'); // 1
+* sequence('user'); // 2
+* resetSequence('user');
+* sequence('user'); // 1
+*
+* resetSequence('order', 1000);
+* sequence('order'); // 1001
+* ```
+*/
+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.
+* Useful for cleaning up between test suites to ensure predictable sequences.
+*
+* @example
+* ```typescript
+* // In test setup
+* beforeEach(() => {
+*   resetAllSequences();
+* });
+*
+* it('starts sequences from 1', () => {
+*   expect(sequence()).toBe(1);
+*   expect(sequence('user')).toBe(1);
+* });
+* ```
+*/
+function resetAllSequences() {
+	sequences.clear();
+}
+/**
+* Generates a random price as a number.
+* Converts faker's string price to a numeric value.
+*
+* @returns A random price number
+*
+* @example
+* ```typescript
+* const productPrice = price(); // 29.99
+* const total = price() * quantity; // Numeric calculation
+* ```
+*/
+function price() {
+	return +faker$1.commerce.price();
+}
+/**
+* Enhanced faker instance with additional utility methods for testing.
+* Extends @faker-js/faker with custom methods for common test data generation patterns.
+*
+* @example
+* ```typescript
+* import { faker } from '@geekmidas/testkit';
+*
+* // Use standard faker methods
+* const name = faker.person.fullName();
+* const email = faker.internet.email();
+*
+* // Use custom extensions
+* const { createdAt, updatedAt } = faker.timestamps();
+* const id = faker.identifier('user');
+* const orderNumber = faker.sequence('order');
+* const productPrice = faker.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 };