@geekmidas/testkit 0.4.0 → 0.6.0

package/src/faker.ts

@@ -18,46 +18,46 @@ import { faker as baseFaker } from '@faker-js/faker';
  * ```
  */
 class AtomicCounter {
-  /**
-   * The current counter value.
-   * @private
-   */
-  private value: number;
-
-  /**
-   * 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(): number {
-    // In Node.js, JavaScript is single-threaded within the event loop,
-    // so this operation is already atomic. However, this class provides
-    // a cleaner abstraction and makes the intent explicit.
-    return ++this.value;
-  }
-
-  /**
-   * Gets the current counter value without incrementing.
-   * @returns The current value
-   */
-  get(): number {
-    return this.value;
-  }
-
-  /**
-   * Resets the counter to a specific value.
-   * @param value - The new value (default: 0)
-   */
-  reset(value = 0): void {
-    this.value = value;
-  }
+	/**
+	 * The current counter value.
+	 * @private
+	 */
+	private value: number;
+
+	/**
+	 * 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(): number {
+		// In Node.js, JavaScript is single-threaded within the event loop,
+		// so this operation is already atomic. However, this class provides
+		// a cleaner abstraction and makes the intent explicit.
+		return ++this.value;
+	}
+
+	/**
+	 * Gets the current counter value without incrementing.
+	 * @returns The current value
+	 */
+	get(): number {
+		return this.value;
+	}
+
+	/**
+	 * Resets the counter to a specific value.
+	 * @param value - The new value (default: 0)
+	 */
+	reset(value = 0): void {
+		this.value = value;
+	}
 }
 
 /**
@@ -81,16 +81,16 @@ class AtomicCounter {
  * ```
  */
 export function timestamps(): Timestamps {
-  const createdAt = faker.date.past();
-  const updatedAt = faker.date.between({
-    from: createdAt,
-    to: new Date(),
-  });
+	const createdAt = faker.date.past();
+	const updatedAt = faker.date.between({
+		from: createdAt,
+		to: new Date(),
+	});
 
-  createdAt.setMilliseconds(0);
-  updatedAt.setMilliseconds(0);
+	createdAt.setMilliseconds(0);
+	updatedAt.setMilliseconds(0);
 
-  return { createdAt, updatedAt };
+	return { createdAt, updatedAt };
 }
 
 /**
@@ -108,11 +108,11 @@ export function timestamps(): Timestamps {
  * ```
  */
 export function identifier(suffix?: string): string {
-  return [
-    faker.internet.domainSuffix(),
-    faker.internet.domainWord(),
-    suffix ? suffix : faker.internet.domainWord() + sequence('identifier'),
-  ].join('.');
+	return [
+		faker.internet.domainSuffix(),
+		faker.internet.domainWord(),
+		suffix ? suffix : faker.internet.domainWord() + sequence('identifier'),
+	].join('.');
 }
 
 /**
@@ -143,12 +143,12 @@ const sequences = new Map<string, AtomicCounter>();
  * ```
  */
 export function sequence(name = 'default'): number {
-  if (!sequences.has(name)) {
-    sequences.set(name, new AtomicCounter());
-  }
+	if (!sequences.has(name)) {
+		sequences.set(name, new AtomicCounter());
+	}
 
-  const counter = sequences.get(name) as AtomicCounter;
-  return counter.increment();
+	const counter = sequences.get(name) as AtomicCounter;
+	return counter.increment();
 }
 
 /**
@@ -170,12 +170,12 @@ export function sequence(name = 'default'): number {
  * ```
  */
 export function resetSequence(name = 'default', value = 0): void {
-  if (sequences.has(name)) {
-    const counter = sequences.get(name) as AtomicCounter;
-    counter.reset(value);
-  } else {
-    sequences.set(name, new AtomicCounter(value));
-  }
+	if (sequences.has(name)) {
+		const counter = sequences.get(name) as AtomicCounter;
+		counter.reset(value);
+	} else {
+		sequences.set(name, new AtomicCounter(value));
+	}
 }
 
 /**
@@ -196,7 +196,7 @@ export function resetSequence(name = 'default', value = 0): void {
  * ```
  */
 export function resetAllSequences(): void {
-  sequences.clear();
+	sequences.clear();
 }
 
 /**
@@ -212,89 +212,89 @@ export function resetAllSequences(): void {
  * ```
  */
 function price(): number {
-  return +faker.commerce.price();
+	return +faker.commerce.price();
 }
 
 type Coordinate = {
-  lat: number;
-  lng: number;
+	lat: number;
+	lng: number;
 };
 
 export function coordinateInRadius(
-  center: Coordinate,
-  radius: number,
+	center: Coordinate,
+	radius: number,
 ): Coordinate {
-  // Earth's radius in meters
-  const earth = 6378137;
-  // Convert radius from meters to degrees
-  const d = radius / earth;
-
-  // Random bearing and distance
-  const theta = 2 * Math.PI * Math.random();
-  const r = d * Math.sqrt(Math.random());
-
-  const lat1 = (center.lat * Math.PI) / 180;
-  const lng1 = (center.lng * Math.PI) / 180;
-
-  const lat2 = Math.asin(
-    Math.sin(lat1) * Math.cos(r) +
-      Math.cos(lat1) * Math.sin(r) * Math.cos(theta),
-  );
-  const lng2 =
-    lng1 +
-    Math.atan2(
-      Math.sin(theta) * Math.sin(r) * Math.cos(lat1),
-      Math.cos(r) - Math.sin(lat1) * Math.sin(lat2),
-    );
-
-  return {
-    lat: (lat2 * 180) / Math.PI,
-    lng: (lng2 * 180) / Math.PI,
-  };
+	// Earth's radius in meters
+	const earth = 6378137;
+	// Convert radius from meters to degrees
+	const d = radius / earth;
+
+	// Random bearing and distance
+	const theta = 2 * Math.PI * Math.random();
+	const r = d * Math.sqrt(Math.random());
+
+	const lat1 = (center.lat * Math.PI) / 180;
+	const lng1 = (center.lng * Math.PI) / 180;
+
+	const lat2 = Math.asin(
+		Math.sin(lat1) * Math.cos(r) +
+			Math.cos(lat1) * Math.sin(r) * Math.cos(theta),
+	);
+	const lng2 =
+		lng1 +
+		Math.atan2(
+			Math.sin(theta) * Math.sin(r) * Math.cos(lat1),
+			Math.cos(r) - Math.sin(lat1) * Math.sin(lat2),
+		);
+
+	return {
+		lat: (lat2 * 180) / Math.PI,
+		lng: (lng2 * 180) / Math.PI,
+	};
 }
 
 function coordinateOutsideRadius(
-  center: Coordinate,
-  minRadiusMeters: number,
-  maxRadiusMeters: number,
+	center: Coordinate,
+	minRadiusMeters: number,
+	maxRadiusMeters: number,
 ): Coordinate {
-  // Earth's radius in meters
-  const earth = 6378137;
-
-  // Convert radii from meters to radians
-  const minD = minRadiusMeters / earth;
-  const maxD = maxRadiusMeters / earth;
-
-  // Random bearing
-  const theta = 2 * Math.PI * Math.random();
-
-  // Random distance in annular ring (uniform distribution by area)
-  // For uniform distribution in annulus: r = sqrt(r_min² + (r_max² - r_min²) * random)
-  const r = Math.sqrt(
-    minD * minD + (maxD * maxD - minD * minD) * Math.random(),
-  );
-
-  const lat1 = (center.lat * Math.PI) / 180;
-  const lng1 = (center.lng * Math.PI) / 180;
-
-  const lat2 = Math.asin(
-    Math.sin(lat1) * Math.cos(r) +
-      Math.cos(lat1) * Math.sin(r) * Math.cos(theta),
-  );
-  const lng2 =
-    lng1 +
-    Math.atan2(
-      Math.sin(theta) * Math.sin(r) * Math.cos(lat1),
-      Math.cos(r) - Math.sin(lat1) * Math.sin(lat2),
-    );
-
-  // Normalize longitude to [-180, 180]
-  const normalizedLng = (((lng2 * 180) / Math.PI + 540) % 360) - 180;
-
-  return {
-    lat: (lat2 * 180) / Math.PI,
-    lng: normalizedLng,
-  };
+	// Earth's radius in meters
+	const earth = 6378137;
+
+	// Convert radii from meters to radians
+	const minD = minRadiusMeters / earth;
+	const maxD = maxRadiusMeters / earth;
+
+	// Random bearing
+	const theta = 2 * Math.PI * Math.random();
+
+	// Random distance in annular ring (uniform distribution by area)
+	// For uniform distribution in annulus: r = sqrt(r_min² + (r_max² - r_min²) * random)
+	const r = Math.sqrt(
+		minD * minD + (maxD * maxD - minD * minD) * Math.random(),
+	);
+
+	const lat1 = (center.lat * Math.PI) / 180;
+	const lng1 = (center.lng * Math.PI) / 180;
+
+	const lat2 = Math.asin(
+		Math.sin(lat1) * Math.cos(r) +
+			Math.cos(lat1) * Math.sin(r) * Math.cos(theta),
+	);
+	const lng2 =
+		lng1 +
+		Math.atan2(
+			Math.sin(theta) * Math.sin(r) * Math.cos(lat1),
+			Math.cos(r) - Math.sin(lat1) * Math.sin(lat2),
+		);
+
+	// Normalize longitude to [-180, 180]
+	const normalizedLng = (((lng2 * 180) / Math.PI + 540) % 360) - 180;
+
+	return {
+		lat: (lat2 * 180) / Math.PI,
+		lng: normalizedLng,
+	};
 }
 
 /**
@@ -317,18 +317,18 @@ function coordinateOutsideRadius(
  * ```
  */
 export const faker = Object.freeze(
-  Object.assign({}, baseFaker, {
-    timestamps,
-    identifier,
-    sequence,
-    resetSequence,
-    resetAllSequences,
-    price,
-    coordinates: {
-      within: coordinateInRadius,
-      outside: coordinateOutsideRadius,
-    },
-  }),
+	Object.assign({}, baseFaker, {
+		timestamps,
+		identifier,
+		sequence,
+		resetSequence,
+		resetAllSequences,
+		price,
+		coordinates: {
+			within: coordinateInRadius,
+			outside: coordinateOutsideRadius,
+		},
+	}),
 );
 
 /**
@@ -336,10 +336,10 @@ export const faker = Object.freeze(
  * Used by the timestamps() function to generate date fields.
  */
 export type Timestamps = {
-  /** The creation date */
-  createdAt: Date;
-  /** The last update date */
-  updatedAt: Date;
+	/** The creation date */
+	createdAt: Date;
+	/** The last update date */
+	updatedAt: Date;
 };
 
 /**

package/src/helpers.ts

@@ -36,10 +36,10 @@ import pg from 'pg';
  * ```
  */
 export function createKyselyDb<Database>(config: any): Kysely<Database> {
-  return new Kysely({
-    dialect: new PostgresDialect({
-      pool: new pg.Pool(config),
-    }),
-    plugins: [new CamelCasePlugin()],
-  });
+	return new Kysely({
+		dialect: new PostgresDialect({
+			pool: new pg.Pool(config),
+		}),
+		plugins: [new CamelCasePlugin()],
+	});
 }

package/src/kysely.ts

@@ -2,10 +2,10 @@ import type { Kysely, Transaction } from 'kysely';
 import type { TestAPI } from 'vitest';
 import { VitestKyselyTransactionIsolator } from './VitestKyselyTransactionIsolator';
 import {
-  type DatabaseConnection,
-  type FixtureCreators,
-  type IsolationLevel,
-  extendWithFixtures as baseExtendWithFixtures,
+	extendWithFixtures as baseExtendWithFixtures,
+	type DatabaseConnection,
+	type FixtureCreators,
+	type IsolationLevel,
 } from './VitestTransactionIsolator';
 
 /**
@@ -13,38 +13,38 @@ import {
  * Provides factories, migrators, and transaction isolators for Kysely ORM.
  */
 
-export { KyselyFactory } from './KyselyFactory';
 export type { ExtractSeedAttrs, FactorySeed } from './Factory';
+export { KyselyFactory } from './KyselyFactory';
 export { PostgresKyselyMigrator } from './PostgresKyselyMigrator';
 export { VitestKyselyTransactionIsolator } from './VitestKyselyTransactionIsolator';
-export { IsolationLevel } from './VitestTransactionIsolator';
 export type {
-  DatabaseFixtures,
-  ExtendedDatabaseFixtures,
-  FixtureCreators,
-  TestWithExtendedFixtures,
-  TransactionWrapperOptions,
+	DatabaseFixtures,
+	ExtendedDatabaseFixtures,
+	FixtureCreators,
+	TestWithExtendedFixtures,
+	TransactionWrapperOptions,
 } from './VitestTransactionIsolator';
+export { IsolationLevel } from './VitestTransactionIsolator';
 
 /**
  * Kysely-specific options for transaction wrapping.
  */
 export interface KyselyTransactionOptions<
-  Database,
-  Extended extends Record<string, unknown> = {},
+	Database,
+	Extended extends Record<string, unknown> = {},
 > {
-  /** Function that creates or returns a Kysely database instance */
-  connection: DatabaseConnection<Kysely<Database>>;
-  /** Optional setup function to run within the transaction before each test */
-  setup?: (trx: Transaction<Database>) => Promise<void>;
-  /** Transaction isolation level (defaults to REPEATABLE_READ) */
-  isolationLevel?: IsolationLevel;
-  /** Additional fixtures that depend on the transaction */
-  fixtures?: FixtureCreators<Transaction<Database>, Extended>;
+	/** Function that creates or returns a Kysely database instance */
+	connection: DatabaseConnection<Kysely<Database>>;
+	/** Optional setup function to run within the transaction before each test */
+	setup?: (trx: Transaction<Database>) => Promise<void>;
+	/** Transaction isolation level (defaults to REPEATABLE_READ) */
+	isolationLevel?: IsolationLevel;
+	/** Additional fixtures that depend on the transaction */
+	fixtures?: FixtureCreators<Transaction<Database>, Extended>;
 }
 
 // Re-export faker and FakerFactory for type portability in declaration files
-export { faker, type FakerFactory } from './faker';
+export { type FakerFactory, faker } from './faker';
 
 /**
  * Creates a wrapped Vitest test API with automatic transaction rollback for Kysely.
@@ -94,12 +94,12 @@ export { faker, type FakerFactory } from './faker';
  * ```
  */
 export function wrapVitestKyselyTransaction<
-  Database,
-  Extended extends Record<string, unknown> = {},
+	Database,
+	Extended extends Record<string, unknown> = {},
 >(api: TestAPI, options: KyselyTransactionOptions<Database, Extended>) {
-  const wrapper = new VitestKyselyTransactionIsolator<Database>(api);
+	const wrapper = new VitestKyselyTransactionIsolator<Database>(api);
 
-  return wrapper.wrapVitestWithTransaction(options);
+	return wrapper.wrapVitestWithTransaction(options);
 }
 
 /**
@@ -155,12 +155,12 @@ export function wrapVitestKyselyTransaction<
  * ```
  */
 export function extendWithFixtures<
-  Database,
-  Extended extends Record<string, unknown>,
-  T extends ReturnType<TestAPI['extend']> = ReturnType<TestAPI['extend']>,
+	Database,
+	Extended extends Record<string, unknown>,
+	T extends ReturnType<TestAPI['extend']> = ReturnType<TestAPI['extend']>,
 >(wrappedTest: T, fixtures: FixtureCreators<Transaction<Database>, Extended>) {
-  return baseExtendWithFixtures<Transaction<Database>, Extended, T>(
-    wrappedTest,
-    fixtures,
-  );
+	return baseExtendWithFixtures<Transaction<Database>, Extended, T>(
+		wrappedTest,
+		fixtures,
+	);
 }

package/src/logger.ts

@@ -5,14 +5,14 @@ import { vi } from 'vitest';
  * Creates a mock Logger for testing
  */
 export function createMockLogger(): Logger {
-  const logger: Logger = {
-    debug: vi.fn(),
-    info: vi.fn(),
-    warn: vi.fn(),
-    error: vi.fn(),
-    fatal: vi.fn(),
-    trace: vi.fn(),
-    child: vi.fn(() => logger),
-  };
-  return logger;
+	const logger: Logger = {
+		debug: vi.fn(),
+		info: vi.fn(),
+		warn: vi.fn(),
+		error: vi.fn(),
+		fatal: vi.fn(),
+		trace: vi.fn(),
+		child: vi.fn(() => logger),
+	};
+	return logger;
 }

package/src/objection.ts

@@ -2,10 +2,10 @@ import type { Knex } from 'knex';
 import type { TestAPI } from 'vitest';
 import { VitestObjectionTransactionIsolator } from './VitestObjectionTransactionIsolator';
 import {
-  type DatabaseConnection,
-  type FixtureCreators,
-  type IsolationLevel,
-  extendWithFixtures as baseExtendWithFixtures,
+	extendWithFixtures as baseExtendWithFixtures,
+	type DatabaseConnection,
+	type FixtureCreators,
+	type IsolationLevel,
 } from './VitestTransactionIsolator';
 
 /**
@@ -14,37 +14,37 @@ import {
  * and transaction isolation for test suites.
  */
 
-export { ObjectionFactory } from './ObjectionFactory';
 export type { ExtractSeedAttrs, FactorySeed } from './Factory';
-export { VitestObjectionTransactionIsolator } from './VitestObjectionTransactionIsolator';
-export { IsolationLevel } from './VitestTransactionIsolator';
+export { ObjectionFactory } from './ObjectionFactory';
 export { PostgresObjectionMigrator } from './PostgresObjectionMigrator';
+export { VitestObjectionTransactionIsolator } from './VitestObjectionTransactionIsolator';
 export type {
-  DatabaseFixtures,
-  ExtendedDatabaseFixtures,
-  FixtureCreators,
-  TestWithExtendedFixtures,
-  TransactionWrapperOptions,
+	DatabaseFixtures,
+	ExtendedDatabaseFixtures,
+	FixtureCreators,
+	TestWithExtendedFixtures,
+	TransactionWrapperOptions,
 } from './VitestTransactionIsolator';
+export { IsolationLevel } from './VitestTransactionIsolator';
 
 /**
  * Objection.js-specific options for transaction wrapping.
  */
 export interface ObjectionTransactionOptions<
-  Extended extends Record<string, unknown> = {},
+	Extended extends Record<string, unknown> = {},
 > {
-  /** Function that creates or returns a Knex database connection */
-  connection: DatabaseConnection<Knex>;
-  /** Optional setup function to run within the transaction before each test */
-  setup?: (trx: Knex.Transaction) => Promise<void>;
-  /** Transaction isolation level (defaults to REPEATABLE_READ) */
-  isolationLevel?: IsolationLevel;
-  /** Additional fixtures that depend on the transaction */
-  fixtures?: FixtureCreators<Knex.Transaction, Extended>;
+	/** Function that creates or returns a Knex database connection */
+	connection: DatabaseConnection<Knex>;
+	/** Optional setup function to run within the transaction before each test */
+	setup?: (trx: Knex.Transaction) => Promise<void>;
+	/** Transaction isolation level (defaults to REPEATABLE_READ) */
+	isolationLevel?: IsolationLevel;
+	/** Additional fixtures that depend on the transaction */
+	fixtures?: FixtureCreators<Knex.Transaction, Extended>;
 }
 
 // Re-export faker and FakerFactory for type portability in declaration files
-export { faker, type FakerFactory } from './faker';
+export { type FakerFactory, faker } from './faker';
 
 /**
  * Creates a wrapped Vitest test API with automatic transaction rollback for Objection.js.
@@ -91,11 +91,11 @@ export { faker, type FakerFactory } from './faker';
  * ```
  */
 export function wrapVitestObjectionTransaction<
-  Extended extends Record<string, unknown> = {},
+	Extended extends Record<string, unknown> = {},
 >(api: TestAPI, options: ObjectionTransactionOptions<Extended>) {
-  const wrapper = new VitestObjectionTransactionIsolator(api);
+	const wrapper = new VitestObjectionTransactionIsolator(api);
 
-  return wrapper.wrapVitestWithTransaction(options);
+	return wrapper.wrapVitestWithTransaction(options);
 }
 
 /**
@@ -147,11 +147,11 @@ export function wrapVitestObjectionTransaction<
  * ```
  */
 export function extendWithFixtures<
-  Extended extends Record<string, unknown>,
-  T extends ReturnType<TestAPI['extend']> = ReturnType<TestAPI['extend']>,
+	Extended extends Record<string, unknown>,
+	T extends ReturnType<TestAPI['extend']> = ReturnType<TestAPI['extend']>,
 >(wrappedTest: T, fixtures: FixtureCreators<Knex.Transaction, Extended>) {
-  return baseExtendWithFixtures<Knex.Transaction, Extended, T>(
-    wrappedTest,
-    fixtures,
-  );
+	return baseExtendWithFixtures<Knex.Transaction, Extended, T>(
+		wrappedTest,
+		fixtures,
+	);
 }

package/src/os/directory.ts

@@ -5,17 +5,18 @@ import path from 'node:path';
 import { it } from 'vitest';
 
 export const itWithDir = it.extend<DirectoryFixtures>({
-  // This fixture automatically provides a transaction to each test
-  dir: async ({}, use) => {
-    const tempDir = os.tmpdir();
-    const directoryName = crypto.randomUUID().replace(/-/g, '').toUpperCase();
-    const dir = path.join(tempDir, directoryName);
-    await fs.mkdir(dir, { recursive: true });
-    await use(dir);
-    await fs.rm(dir, { recursive: true, force: true });
-  },
+	// This fixture automatically provides a transaction to each test
+	// biome-ignore lint/correctness/noEmptyPattern: this has to be like this to satisfy Biome
+	dir: async ({}, use) => {
+		const tempDir = os.tmpdir();
+		const directoryName = crypto.randomUUID().replace(/-/g, '').toUpperCase();
+		const dir = path.join(tempDir, directoryName);
+		await fs.mkdir(dir, { recursive: true });
+		await use(dir);
+		await fs.rm(dir, { recursive: true, force: true });
+	},
 });
 
 export interface DirectoryFixtures {
-  dir: string;
+	dir: string;
 }

package/src/timer.ts

@@ -1,3 +1,3 @@
 export function waitFor(ms: number) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
+	return new Promise((resolve) => setTimeout(resolve, ms));
 }