@geekmidas/testkit 3.1.1 → 10.0.0-alpha.0

package/src/objection.ts

@@ -1,157 +0,0 @@
-import type { Knex } from 'knex';
-import type { TestAPI } from 'vitest';
-import { VitestObjectionTransactionIsolator } from './VitestObjectionTransactionIsolator';
-import {
-	extendWithFixtures as baseExtendWithFixtures,
-	type DatabaseConnection,
-	type FixtureCreators,
-	type IsolationLevel,
-} from './VitestTransactionIsolator';
-
-/**
- * Objection.js-specific exports for test utilities.
- * Provides factory implementation for creating test data with Objection.js ORM
- * and transaction isolation for test suites.
- */
-
-export type { ExtractSeedAttrs, FactorySeed } from './Factory';
-export { ObjectionFactory } from './ObjectionFactory';
-export { PostgresObjectionMigrator } from './PostgresObjectionMigrator';
-export { VitestObjectionTransactionIsolator } from './VitestObjectionTransactionIsolator';
-export type {
-	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> = {},
-> {
-	/** 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 { type FakerFactory, faker } from './faker';
-
-/**
- * Creates a wrapped Vitest test API with automatic transaction rollback for Objection.js.
- * 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 Extended - Additional fixtures to provide
- * @param api - The Vitest test API (usually `test` from vitest)
- * @param options - Configuration options for transaction wrapping
- * @returns A wrapped test API that provides transaction isolation
- *
- * @example
- * ```typescript
- * import { test } from 'vitest';
- * import { wrapVitestObjectionTransaction } from '@geekmidas/testkit/objection';
- * import { knex } from './database';
- * import { User } from './models';
- *
- * // Create isolated test with automatic rollback
- * const isolatedTest = wrapVitestObjectionTransaction(test, {
- *   connection: knex,
- * });
- *
- * // Use in tests - each test gets its own transaction
- * isolatedTest('should create user', async ({ trx }) => {
- *   const user = await User.query(trx)
- *     .insert({ name: 'Test User', email: 'test@example.com' });
- *
- *   expect(user).toBeDefined();
- * });
- *
- * // With fixtures for factories
- * const it = wrapVitestObjectionTransaction<{ factory: Factory }>(test, {
- *   connection: knex,
- *   fixtures: {
- *     factory: (trx) => new Factory(trx),
- *   },
- * });
- *
- * it('should create user with factory', async ({ trx, factory }) => {
- *   const user = await factory.insert('user', { name: 'Test' });
- *   expect(user.id).toBeDefined();
- * });
- * ```
- */
-export function wrapVitestObjectionTransaction<
-	Extended extends Record<string, unknown> = {},
->(api: TestAPI, options: ObjectionTransactionOptions<Extended>) {
-	const wrapper = new VitestObjectionTransactionIsolator(api);
-
-	return wrapper.wrapVitestWithTransaction(options);
-}
-
-/**
- * Extends an Objection.js transaction-wrapped test with additional fixtures.
- * Each fixture receives the transaction and can create dependencies like factories or repositories.
- *
- * @template Extended - The type of additional fixtures to provide
- * @param wrappedTest - The base wrapped test from wrapVitestObjectionTransaction
- * @param fixtures - Object mapping fixture names to creator functions
- * @returns An extended test API with both trx and the additional fixtures
- *
- * @example
- * ```typescript
- * import { test } from 'vitest';
- * import { wrapVitestObjectionTransaction, extendWithFixtures, ObjectionFactory } from '@geekmidas/testkit/objection';
- * import { User } from './models';
- *
- * // Define your builders
- * const builders = {
- *   user: ObjectionFactory.createBuilder(User, ({ faker }) => ({
- *     name: faker.person.fullName(),
- *     email: faker.internet.email(),
- *   })),
- * };
- *
- * // Create base wrapped test
- * const baseTest = wrapVitestObjectionTransaction(test, {
- *   connection: knex,
- *   setup: createTestTables,
- * });
- *
- * // Extend with fixtures - each fixture receives the transaction
- * const it = extendWithFixtures<{ factory: ObjectionFactory<typeof builders, {}> }>(
- *   baseTest,
- *   {
- *     factory: (trx) => new ObjectionFactory(builders, {}, trx),
- *   }
- * );
- *
- * // Use in tests - both trx and factory are available
- * it('should create user with factory', async ({ trx, factory }) => {
- *   const user = await factory.insert('user', { name: 'Test User' });
- *   expect(user.id).toBeDefined();
- *
- *   // Verify in database
- *   const found = await User.query(trx).findById(user.id);
- *   expect(found?.name).toBe('Test User');
- * });
- * ```
- */
-export function extendWithFixtures<
-	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,
-	);
-}

package/src/os/directory.ts

@@ -1,26 +0,0 @@
-import crypto from 'node:crypto';
-import fs from 'node:fs/promises';
-import os from 'node:os';
-import path from 'node:path';
-import { it } from 'vitest';
-
-export const itWithDir = it.extend<DirectoryFixtures>({
-	// 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 });
-
-		// Clean up keystore directory that may have been created at ~/.gkm/{directoryName}
-		const keystoreDir = path.join(os.homedir(), '.gkm', directoryName);
-		await fs.rm(keystoreDir, { recursive: true, force: true });
-	},
-});
-
-export interface DirectoryFixtures {
-	dir: string;
-}

package/src/os/index.ts

@@ -1 +0,0 @@
-export { itWithDir } from './directory';

package/src/requestContext.ts

@@ -1,119 +0,0 @@
-import { randomUUID } from 'node:crypto';
-import type { Logger } from '@geekmidas/logger';
-import { ConsoleLogger } from '@geekmidas/logger/console';
-import {
-	enterRequestContext,
-	exitRequestContext,
-	runWithRequestContext,
-	type ServiceContext,
-	serviceContext,
-} from '@geekmidas/services';
-import type { TestAPI } from 'vitest';
-
-/**
- * Options for setting up a request context in tests. Any field omitted
- * is filled with a test-friendly default (ConsoleLogger, random UUID,
- * Date.now()).
- */
-export interface RequestContextOptions {
-	/** Logger exposed via serviceContext.getLogger(). */
-	logger?: Logger;
-	/** Request id exposed via serviceContext.getRequestId(). */
-	requestId?: string;
-	/** Start time exposed via serviceContext.getRequestStartTime(). */
-	startTime?: number;
-}
-
-function resolveContext(opts: RequestContextOptions = {}) {
-	return {
-		logger: opts.logger ?? new ConsoleLogger({ app: 'test' }),
-		requestId: opts.requestId ?? randomUUID(),
-		startTime: opts.startTime ?? Date.now(),
-	};
-}
-
-/**
- * Run a function inside a request context with test-friendly defaults.
- * Useful when you need `serviceContext` to be available for a single call
- * (e.g. invoking `Service.register({ context })` outside a wrapped test).
- *
- * @example
- * ```ts
- * await runInRequestContext(() =>
- *   discovery.register([databaseService]),
- * );
- * ```
- */
-export function runInRequestContext<T>(
-	fn: () => T | Promise<T>,
-	opts: RequestContextOptions = {},
-): T | Promise<T> {
-	return runWithRequestContext(resolveContext(opts), fn);
-}
-
-/**
- * Vitest fixture creator. Spread the result into `.extend()` and every test
- * runs inside `runWithRequestContext`, even tests that don't destructure
- * `requestContext` directly (the fixture is registered as `auto`).
- *
- * @example
- * ```ts
- * const it = test.extend({ ...requestContextFixture() });
- *
- * it('registers services with context', async ({ requestContext }) => {
- *   await discovery.register([databaseService]);
- *   expect(requestContext.getRequestId()).toBeDefined();
- * });
- * ```
- */
-export function requestContextFixture(opts: RequestContextOptions = {}) {
-	return {
-		requestContext: [
-			async (
-				// biome-ignore lint/correctness/noEmptyPattern: vitest fixture signature
-				{}: {},
-				use: (value: ServiceContext) => Promise<void>,
-			) => {
-				// Vitest suspends the fixture on `await use(...)` and runs the test
-				// body in a continuation of the runner's async context. A scoped
-				// `runWithRequestContext` callback ends as soon as we hand control
-				// to the runner, so the test body would see no context. Instead,
-				// mutate the current task's store with `enterRequestContext` —
-				// async/await preserves that store across the suspension, so the
-				// test body sees it. We restore on the way out so subsequent tests
-				// don't inherit the value.
-				enterRequestContext(resolveContext(opts));
-				try {
-					await use(serviceContext);
-				} finally {
-					exitRequestContext();
-				}
-			},
-			{ auto: true },
-		] as const,
-	};
-}
-
-/**
- * Wrap any Vitest `TestAPI` (including the one returned by
- * `wrapVitestKyselyTransaction`) so every test runs inside
- * `runWithRequestContext`. Compose with the transaction wrappers:
- *
- * @example
- * ```ts
- * import { wrapVitestKyselyTransaction } from '@geekmidas/testkit/kysely';
- * import { withRequestContext } from '@geekmidas/testkit/request-context';
- *
- * const baseIt = wrapVitestKyselyTransaction<DB>(it, { connection: db });
- * const itWithCtx = withRequestContext(baseIt);
- *
- * itWithCtx('runs inside trx + context', async ({ trx, requestContext }) => {
- *   // serviceContext is set up; Service.register({ context }) works here.
- * });
- * ```
- */
-export function withRequestContext<
-	T extends TestAPI | ReturnType<TestAPI['extend']>,
->(testApi: T, opts: RequestContextOptions = {}): T {
-	return (testApi as any).extend(requestContextFixture(opts));
-}

package/src/timer.ts

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

package/test/globalSetup.ts

@@ -1,54 +0,0 @@
-import { Client } from 'pg';
-
-const TEST_DATABASE_NAME = 'geekmidas_test';
-
-export const TEST_DATABASE_CONFIG = {
-	host: 'localhost',
-	port: 5432,
-	user: 'geekmidas',
-	password: 'geekmidas',
-	database: TEST_DATABASE_NAME,
-};
-
-export default async function globalSetup() {
-	const adminConfig = {
-		host: TEST_DATABASE_CONFIG.host,
-		port: TEST_DATABASE_CONFIG.port,
-		user: TEST_DATABASE_CONFIG.user,
-		password: TEST_DATABASE_CONFIG.password,
-		database: 'postgres', // Connect to default postgres database
-	};
-
-	const client = new Client(adminConfig);
-
-	try {
-		await client.connect();
-
-		// Check if test database exists
-		const result = await client.query(
-			`SELECT * FROM pg_catalog.pg_database WHERE datname = $1`,
-			[TEST_DATABASE_NAME],
-		);
-
-		// Create test database if it doesn't exist
-		if (result.rowCount === 0) {
-			await client.query(`CREATE DATABASE "${TEST_DATABASE_NAME}"`);
-		} else {
-		}
-	} finally {
-		await client.end();
-	}
-
-	// Return cleanup function that drops the database
-	return async () => {
-		const cleanupClient = new Client(adminConfig);
-		try {
-			await cleanupClient.connect();
-			await cleanupClient.query(
-				`DROP DATABASE IF EXISTS "${TEST_DATABASE_NAME}"`,
-			);
-		} finally {
-			await cleanupClient.end();
-		}
-	};
-}

package/test/helpers.ts

@@ -1,268 +0,0 @@
-import type { Knex } from 'knex';
-import knex from 'knex';
-import {
-	CamelCasePlugin,
-	type ControlledTransaction,
-	Kysely,
-	PostgresDialect,
-	sql,
-} from 'kysely';
-// `Migrator` moved to the 'kysely/migration' subpath in kysely 0.29+.
-import type { Migrator } from 'kysely/migration';
-import pg from 'pg';
-import { TEST_DATABASE_CONFIG } from './globalSetup';
-
-export interface TestDatabase {
-	users: {
-		id: number;
-		name: string;
-		email: string;
-		role?: 'admin' | 'user';
-		createdAt: Date;
-		updatedAt?: Date;
-	};
-	posts: {
-		id: number;
-		title: string;
-		content: string;
-		userId: number;
-		published?: boolean;
-		createdAt: Date;
-		updatedAt?: Date;
-	};
-	comments: {
-		id: number;
-		content: string;
-		postId: number;
-		userId: number;
-		createdAt: Date;
-	};
-}
-
-/**
- * Creates a Kysely database instance for testing
- */
-export function createKyselyDb(): Kysely<TestDatabase> {
-	return new Kysely({
-		dialect: new PostgresDialect({
-			pool: new pg.Pool(TEST_DATABASE_CONFIG),
-		}),
-		plugins: [new CamelCasePlugin()],
-	});
-}
-
-/**
- * Creates a Knex database instance for testing
- */
-export function createKnexDb(): Knex {
-	return knex({
-		client: 'pg',
-		connection: TEST_DATABASE_CONFIG,
-	});
-}
-
-/**
- * Test setup helper that creates tables within a transaction and returns cleanup
- */
-export async function setupKyselyTest(db: Kysely<TestDatabase>): Promise<{
-	db: Kysely<TestDatabase>;
-	trx: ControlledTransaction<TestDatabase, []>;
-	cleanup: () => Promise<void>;
-}> {
-	const trx = await db.startTransaction().execute();
-
-	// Create tables within the transaction
-	await createTestTables(db);
-
-	const cleanup = async () => {
-		await trx.rollback().execute();
-		await db.destroy();
-	};
-
-	return { db, trx, cleanup };
-}
-
-/**
- * Test setup helper for Knex/Objection that creates tables within a transaction
- */
-export async function setupKnexTest(): Promise<{
-	db: Knex;
-	trx: Knex.Transaction;
-	cleanup: () => Promise<void>;
-}> {
-	const db = createKnexDb();
-	const trx = await db.transaction();
-
-	// Create tables within the transaction
-	await createTestTablesKnex(trx);
-
-	const cleanup = async () => {
-		await trx.rollback();
-		await db.destroy();
-	};
-
-	return { db, trx, cleanup };
-}
-
-/**
- * Creates test tables using Kysely
- */
-export async function createTestTables(
-	db: Kysely<TestDatabase> | ControlledTransaction<TestDatabase, []>,
-): Promise<void> {
-	// Create users table
-	await db.schema
-		.createTable('users')
-		.addColumn('id', 'bigserial', (col) => col.primaryKey())
-		.addColumn('name', 'varchar', (col) => col.notNull())
-		.addColumn('email', 'varchar', (col) => col.notNull().unique())
-		.addColumn('role', 'varchar', (col) => col.defaultTo('user'))
-		.addColumn('created_at', 'timestamp', (col) =>
-			col.defaultTo(sql`now()`).notNull(),
-		)
-		.addColumn('updated_at', 'timestamp', (col) =>
-			col.defaultTo(sql`now()`).notNull(),
-		)
-		.execute();
-
-	// Create posts table
-	await db.schema
-		.createTable('posts')
-		.addColumn('id', 'bigserial', (col) => col.primaryKey())
-		.addColumn('title', 'varchar', (col) => col.notNull())
-		.addColumn('content', 'text', (col) => col.notNull())
-		.addColumn('user_id', 'bigint', (col) =>
-			col.notNull().references('users.id').onDelete('cascade'),
-		)
-		.addColumn('published', 'boolean', (col) => col.defaultTo(false))
-		.addColumn('created_at', 'timestamp', (col) =>
-			col.defaultTo(sql`now()`).notNull(),
-		)
-		.addColumn('updated_at', 'timestamp', (col) =>
-			col.defaultTo(sql`now()`).notNull(),
-		)
-		.execute();
-
-	// Create comments table
-	await db.schema
-		.createTable('comments')
-		.addColumn('id', 'bigserial', (col) => col.primaryKey())
-		.addColumn('content', 'text', (col) => col.notNull())
-		.addColumn('post_id', 'bigint', (col) =>
-			col.notNull().references('posts.id').onDelete('cascade'),
-		)
-		.addColumn('user_id', 'bigint', (col) =>
-			col.notNull().references('users.id').onDelete('cascade'),
-		)
-		.addColumn('created_at', 'timestamp', (col) =>
-			col.defaultTo(sql`now()`).notNull(),
-		)
-		.execute();
-}
-
-/**
- * Creates test tables using Knex
- */
-export async function createTestTablesKnex(
-	trx: Knex.Transaction,
-): Promise<void> {
-	// Create simple users table for testing factory
-	await trx.raw(`CREATE EXTENSION IF NOT EXISTS "uuid-ossp"`);
-	await trx.schema.createTableIfNotExists('users', (table) => {
-		table.uuid('id').primary().defaultTo(trx.raw('uuid_generate_v4()'));
-		table.string('name').notNullable();
-	});
-
-	// Create simple posts table for testing factory
-	await trx.schema.createTableIfNotExists('posts', (table) => {
-		table.uuid('id').primary().defaultTo(trx.raw('uuid_generate_v4()'));
-		table.string('title').notNullable();
-		table
-			.uuid('user_id')
-			.notNullable()
-			.references('id')
-			.inTable('users')
-			.onDelete('cascade');
-	});
-
-	// Create simple comments table for testing factory
-	await trx.schema.createTableIfNotExists('comments', (table) => {
-		table.uuid('id').primary().defaultTo(trx.raw('uuid_generate_v4()'));
-		table.text('content').notNullable();
-		table
-			.uuid('post_id')
-			.notNullable()
-			.references('id')
-			.inTable('posts')
-			.onDelete('cascade');
-		table
-			.uuid('user_id')
-			.notNullable()
-			.references('id')
-			.inTable('users')
-			.onDelete('cascade');
-	});
-}
-
-/**
- * Helper for PostgresMigrator tests - creates a separate test database
- */
-export async function createTestDatabase(
-	dbName: string,
-): Promise<() => Promise<void>> {
-	const adminConfig = {
-		host: TEST_DATABASE_CONFIG.host,
-		port: TEST_DATABASE_CONFIG.port,
-		user: TEST_DATABASE_CONFIG.user,
-		password: TEST_DATABASE_CONFIG.password,
-		database: 'postgres',
-	};
-
-	const client = new pg.Client(adminConfig);
-
-	try {
-		await client.connect();
-
-		// Drop database if it exists, then create it
-		await client.query(`DROP DATABASE IF EXISTS "${dbName}"`);
-		await client.query(`CREATE DATABASE "${dbName}"`);
-	} finally {
-		await client.end();
-	}
-
-	// Return cleanup function
-	return async () => {
-		const cleanupClient = new pg.Client(adminConfig);
-		try {
-			await cleanupClient.connect();
-			await cleanupClient.query(`DROP DATABASE IF EXISTS "${dbName}"`);
-		} finally {
-			await cleanupClient.end();
-		}
-	};
-}
-
-/**
- * Creates a Kysely migrator for testing
- */
-export function createTestMigrator(
-	db: Kysely<any>,
-	migrations: Record<
-		string,
-		{
-			up: (db: Kysely<any>) => Promise<void>;
-			down: (db: Kysely<any>) => Promise<void>;
-		}
-	>,
-): Migrator {
-	const { Migrator } = require('kysely/migration');
-
-	return new Migrator({
-		db,
-		provider: {
-			async getMigrations() {
-				return migrations;
-			},
-		},
-	});
-}

package/test/migrations/1749664623372_user.ts

@@ -1,22 +0,0 @@
-import { type Kysely, sql } from 'kysely';
-
-// `any` is required here since migrations should be frozen in time. alternatively, keep a "snapshot" db interface.
-export async function up(db: Kysely<any>): Promise<void> {
-	await db.schema
-		.createTable('users')
-		.addColumn('id', 'bigserial', (col) => col.primaryKey())
-		.addColumn('email', 'varchar', (col) => col.notNull().unique())
-		.addColumn('name', 'varchar', (col) => col.notNull())
-		.addColumn('created_at', 'timestamp', (col) =>
-			col.defaultTo(sql`now()`).notNull(),
-		)
-		.addColumn('updated_at', 'timestamp', (col) =>
-			col.defaultTo(sql`now()`).notNull(),
-		)
-		.execute();
-}
-
-// `any` is required here since migrations should be frozen in time. alternatively, keep a "snapshot" db interface.
-export async function down(db: Kysely<any>): Promise<void> {
-	await db.schema.dropTable('users').execute();
-}

package/tsconfig.json

@@ -1,9 +0,0 @@
-{
-  "extends": "../../tsconfig.base.json",
-  "compilerOptions": {
-    "outDir": "./dist",
-    "rootDir": "./src",
-    "composite": true
-  },
-  "include": ["src/**/*"]
-}

package/vitest.config.ts

@@ -1,8 +0,0 @@
-import { defineProject } from 'vitest/config';
-
-export default defineProject({
-	test: {
-		globalSetup: ['test/globalSetup.ts'],
-		pool: 'forks',
-	},
-});