@geekmidas/testkit 0.0.6 → 0.0.8

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 };

package/dist/faker-SMN4ira4.cjs

@@ -0,0 +1,263 @@
+const require_chunk = require('./chunk-CUT6urMc.cjs');
+const __faker_js_faker = require_chunk.__toESM(require("@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.date.past();
+	const updatedAt = faker.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.internet.domainSuffix(),
+		faker.internet.domainWord(),
+		suffix ? suffix : faker.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.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 = Object.freeze(Object.assign({}, __faker_js_faker.faker, {
+	timestamps,
+	identifier,
+	sequence,
+	resetSequence,
+	resetAllSequences,
+	price
+}));
+
+//#endregion
+Object.defineProperty(exports, 'faker', {
+  enumerable: true,
+  get: function () {
+    return faker;
+  }
+});
+Object.defineProperty(exports, 'identifier', {
+  enumerable: true,
+  get: function () {
+    return identifier;
+  }
+});
+Object.defineProperty(exports, 'resetAllSequences', {
+  enumerable: true,
+  get: function () {
+    return resetAllSequences;
+  }
+});
+Object.defineProperty(exports, 'resetSequence', {
+  enumerable: true,
+  get: function () {
+    return resetSequence;
+  }
+});
+Object.defineProperty(exports, 'sequence', {
+  enumerable: true,
+  get: function () {
+    return sequence;
+  }
+});
+Object.defineProperty(exports, 'timestamps', {
+  enumerable: true,
+  get: function () {
+    return timestamps;
+  }
+});

package/dist/faker.cjs

@@ -1,4 +1,4 @@
-const require_faker = require('./faker-caz-8zt8.cjs');
+const require_faker = require('./faker-SMN4ira4.cjs');
 
 exports.faker = require_faker.faker;
 exports.identifier = require_faker.identifier;

package/dist/faker.mjs

@@ -1,3 +1,3 @@
-import { faker, identifier, resetAllSequences, resetSequence, sequence, timestamps } from "./faker-BwaXA_RF.mjs";
+import { faker, identifier, resetAllSequences, resetSequence, sequence, timestamps } from "./faker-CxKkEeYi.mjs";
 
 export { faker, identifier, resetAllSequences, resetSequence, sequence, timestamps };

package/dist/helpers-CKMlwSYT.mjs

@@ -0,0 +1,47 @@
+import { CamelCasePlugin, Kysely, PostgresDialect } from "kysely";
+import pg from "pg";
+
+//#region src/helpers.ts
+/**
+* Creates a Kysely database instance with PostgreSQL dialect and camelCase plugin.
+* This is a convenience function for quickly setting up a Kysely connection for testing.
+*
+* @template Database - The database schema type
+* @param config - PostgreSQL connection configuration (pg.Pool config)
+* @returns A configured Kysely instance
+*
+* @example
+* ```typescript
+* interface Database {
+*   users: UsersTable;
+*   posts: PostsTable;
+* }
+*
+* // Create from connection string
+* const db = createKyselyDb<Database>({
+*   connectionString: 'postgresql://user:pass@localhost:5432/testdb'
+* });
+*
+* // Create with detailed config
+* const db = createKyselyDb<Database>({
+*   host: 'localhost',
+*   port: 5432,
+*   database: 'testdb',
+*   user: 'testuser',
+*   password: 'testpass',
+*   max: 10 // connection pool size
+* });
+*
+* // Use in tests
+* const users = await db.selectFrom('users').selectAll().execute();
+* ```
+*/
+function createKyselyDb(config) {
+	return new Kysely({
+		dialect: new PostgresDialect({ pool: new pg.Pool(config) }),
+		plugins: [new CamelCasePlugin()]
+	});
+}
+
+//#endregion
+export { createKyselyDb };

package/dist/helpers-H4hO5SZR.cjs

@@ -0,0 +1,53 @@
+const require_chunk = require('./chunk-CUT6urMc.cjs');
+const kysely = require_chunk.__toESM(require("kysely"));
+const pg = require_chunk.__toESM(require("pg"));
+
+//#region src/helpers.ts
+/**
+* Creates a Kysely database instance with PostgreSQL dialect and camelCase plugin.
+* This is a convenience function for quickly setting up a Kysely connection for testing.
+*
+* @template Database - The database schema type
+* @param config - PostgreSQL connection configuration (pg.Pool config)
+* @returns A configured Kysely instance
+*
+* @example
+* ```typescript
+* interface Database {
+*   users: UsersTable;
+*   posts: PostsTable;
+* }
+*
+* // Create from connection string
+* const db = createKyselyDb<Database>({
+*   connectionString: 'postgresql://user:pass@localhost:5432/testdb'
+* });
+*
+* // Create with detailed config
+* const db = createKyselyDb<Database>({
+*   host: 'localhost',
+*   port: 5432,
+*   database: 'testdb',
+*   user: 'testuser',
+*   password: 'testpass',
+*   max: 10 // connection pool size
+* });
+*
+* // Use in tests
+* const users = await db.selectFrom('users').selectAll().execute();
+* ```
+*/
+function createKyselyDb(config) {
+	return new kysely.Kysely({
+		dialect: new kysely.PostgresDialect({ pool: new pg.default.Pool(config) }),
+		plugins: [new kysely.CamelCasePlugin()]
+	});
+}
+
+//#endregion
+Object.defineProperty(exports, 'createKyselyDb', {
+  enumerable: true,
+  get: function () {
+    return createKyselyDb;
+  }
+});

package/dist/helpers.cjs

@@ -1,3 +1,3 @@
-const require_helpers = require('./helpers-DOtYCEvZ.cjs');
+const require_helpers = require('./helpers-H4hO5SZR.cjs');
 
 exports.createKyselyDb = require_helpers.createKyselyDb;

package/dist/helpers.mjs

@@ -1,3 +1,3 @@
-import { createKyselyDb } from "./helpers-DN4sJO4i.mjs";
+import { createKyselyDb } from "./helpers-CKMlwSYT.mjs";
 
 export { createKyselyDb };

package/dist/kysely-B-GOhABm.cjs

@@ -0,0 +1,72 @@
+const require_VitestTransactionIsolator = require('./VitestTransactionIsolator-DcOz0LZF.cjs');
+const require_VitestKyselyTransactionIsolator = require('./VitestKyselyTransactionIsolator-YWnSJiIH.cjs');
+
+//#region src/kysely.ts
+/**
+* Creates a wrapped Vitest test API with automatic transaction rollback for Kysely.
+* Each test runs in an isolated database transaction that is rolled back after completion.
+* This ensures tests don't affect each other's data and run faster than truncating tables.
+*
+* @template Database - The database schema type
+* @param api - The Vitest test API (usually `test` from vitest)
+* @param db - The Kysely database instance
+* @param setup - Optional setup function to run before each test in the transaction
+* @param level - Transaction isolation level (defaults to REPEATABLE_READ)
+* @returns A wrapped test API that provides transaction isolation
+*
+* @example
+* ```typescript
+* import { test } from 'vitest';
+* import { wrapVitestKyselyTransaction } from '@geekmidas/testkit/kysely';
+* import { db } from './database';
+*
+* // Create isolated test with automatic rollback
+* const isolatedTest = wrapVitestKyselyTransaction(test, db);
+*
+* // Use in tests - each test gets its own transaction
+* isolatedTest('should create user', async ({ trx }) => {
+*   const user = await trx
+*     .insertInto('users')
+*     .values({ name: 'Test User', email: 'test@example.com' })
+*     .returningAll()
+*     .executeTakeFirst();
+*
+*   expect(user).toBeDefined();
+*   // User is automatically rolled back after test
+* });
+*
+* // With setup function for common test data
+* const testWithSetup = wrapVitestKyselyTransaction(
+*   test,
+*   db,
+*   async (trx) => {
+*     // Create common test data
+*     await trx.insertInto('settings')
+*       .values({ key: 'test_mode', value: 'true' })
+*       .execute();
+*   }
+* );
+*
+* testWithSetup('should have test settings', async ({ trx }) => {
+*   const setting = await trx
+*     .selectFrom('settings')
+*     .where('key', '=', 'test_mode')
+*     .selectAll()
+*     .executeTakeFirst();
+*
+*   expect(setting?.value).toBe('true');
+* });
+* ```
+*/
+function wrapVitestKyselyTransaction(api, db, setup, level = require_VitestTransactionIsolator.IsolationLevel.REPEATABLE_READ) {
+	const wrapper = new require_VitestKyselyTransactionIsolator.VitestKyselyTransactionIsolator(api);
+	return wrapper.wrapVitestWithTransaction(db, setup, level);
+}
+
+//#endregion
+Object.defineProperty(exports, 'wrapVitestKyselyTransaction', {
+  enumerable: true,
+  get: function () {
+    return wrapVitestKyselyTransaction;
+  }
+});