@geekmidas/testkit 0.4.0 → 1.0.0

package/src/PostgresKyselyMigrator.ts

@@ -43,45 +43,45 @@ const logger = console;
  * ```
  */
 export class PostgresKyselyMigrator extends PostgresMigrator {
-  /**
-   * Creates a new PostgresKyselyMigrator instance.
-   *
-   * @param options - Configuration options
-   * @param options.uri - PostgreSQL connection URI
-   * @param options.db - Kysely database instance
-   * @param options.provider - Migration provider for locating migration files
-   */
-  constructor(
-    private options: {
-      uri: string;
-      db: Kysely<any>;
-      provider: MigrationProvider;
-    },
-  ) {
-    super(options.uri);
-  }
+	/**
+	 * Creates a new PostgresKyselyMigrator instance.
+	 *
+	 * @param options - Configuration options
+	 * @param options.uri - PostgreSQL connection URI
+	 * @param options.db - Kysely database instance
+	 * @param options.provider - Migration provider for locating migration files
+	 */
+	constructor(
+		private options: {
+			uri: string;
+			db: Kysely<any>;
+			provider: MigrationProvider;
+		},
+	) {
+		super(options.uri);
+	}
 
-  /**
-   * Executes Kysely migrations to the latest version.
-   * Implements the abstract migrate() method from PostgresMigrator.
-   *
-   * @throws Error if migrations fail to apply
-   * @returns Promise that resolves when all migrations are applied
-   */
-  async migrate(): Promise<void> {
-    const migrator = new Migrator({
-      db: this.options.db,
-      provider: this.options.provider,
-    });
-    const migrations = await migrator.migrateToLatest();
+	/**
+	 * Executes Kysely migrations to the latest version.
+	 * Implements the abstract migrate() method from PostgresMigrator.
+	 *
+	 * @throws Error if migrations fail to apply
+	 * @returns Promise that resolves when all migrations are applied
+	 */
+	async migrate(): Promise<void> {
+		const migrator = new Migrator({
+			db: this.options.db,
+			provider: this.options.provider,
+		});
+		const migrations = await migrator.migrateToLatest();
 
-    if (migrations.error) {
-      logger.error(migrations.error, `Failed to apply migrations`);
-      throw migrations.error;
-    }
+		if (migrations.error) {
+			logger.error(migrations.error, `Failed to apply migrations`);
+			throw migrations.error;
+		}
 
-    await this.options.db.destroy();
+		await this.options.db.destroy();
 
-    logger.log(`Applied ${migrations.results?.length} migrations successfully`);
-  }
+		logger.log(`Applied ${migrations.results?.length} migrations successfully`);
+	}
 }

package/src/PostgresMigrator.ts

@@ -17,21 +17,21 @@ const { Client } = pg;
  * ```
  */
 async function setupClient(uri: string) {
-  const url = new URL(uri);
+	const url = new URL(uri);
 
-  const db = new Client({
-    user: url.username,
-    password: url.password,
-    host: url.hostname,
-    port: parseInt(url.port),
-    database: 'postgres',
-  });
+	const db = new Client({
+		user: url.username,
+		password: url.password,
+		host: url.hostname,
+		port: parseInt(url.port, 10),
+		database: 'postgres',
+	});
 
-  let database = url.pathname.slice(1);
-  if (database.includes('?')) {
-    database = database.substring(0, database.indexOf('?'));
-  }
-  return { database, db };
+	let database = url.pathname.slice(1);
+	if (database.includes('?')) {
+		database = database.substring(0, database.indexOf('?'));
+	}
+	return { database, db };
 }
 
 /**
@@ -64,105 +64,105 @@ const logger = console;
  * ```
  */
 export abstract class PostgresMigrator {
-  /**
-   * Creates a new PostgresMigrator instance.
-   *
-   * @param uri - PostgreSQL connection URI
-   */
-  constructor(private uri: string) {}
+	/**
+	 * Creates a new PostgresMigrator instance.
+	 *
+	 * @param uri - PostgreSQL connection URI
+	 */
+	constructor(private uri: string) {}
 
-  /**
-   * Abstract method to be implemented by subclasses.
-   * Should contain the migration logic for setting up database schema.
-   *
-   * @returns Promise that resolves when migrations are complete
-   */
-  abstract migrate(): Promise<void>;
+	/**
+	 * Abstract method to be implemented by subclasses.
+	 * Should contain the migration logic for setting up database schema.
+	 *
+	 * @returns Promise that resolves when migrations are complete
+	 */
+	abstract migrate(): Promise<void>;
 
-  /**
-   * Creates a PostgreSQL database if it doesn't already exist.
-   * Connects to the 'postgres' database to check and create the target database.
-   *
-   * @param uri - PostgreSQL connection URI
-   * @returns Object indicating whether the database already existed
-   * @private
-   */
-  private static async create(
-    uri: string,
-  ): Promise<{ alreadyExisted: boolean }> {
-    const { database, db } = await setupClient(uri);
-    try {
-      await db.connect();
-      const result = await db.query(
-        `SELECT * FROM pg_catalog.pg_database WHERE datname = '${database}'`,
-      );
+	/**
+	 * Creates a PostgreSQL database if it doesn't already exist.
+	 * Connects to the 'postgres' database to check and create the target database.
+	 *
+	 * @param uri - PostgreSQL connection URI
+	 * @returns Object indicating whether the database already existed
+	 * @private
+	 */
+	private static async create(
+		uri: string,
+	): Promise<{ alreadyExisted: boolean }> {
+		const { database, db } = await setupClient(uri);
+		try {
+			await db.connect();
+			const result = await db.query(
+				`SELECT * FROM pg_catalog.pg_database WHERE datname = '${database}'`,
+			);
 
-      if (result.rowCount === 0) {
-        await db.query(`CREATE DATABASE "${database}"`);
-      }
+			if (result.rowCount === 0) {
+				await db.query(`CREATE DATABASE "${database}"`);
+			}
 
-      return {
-        alreadyExisted: result.rowCount ? result.rowCount > 0 : false,
-      };
-    } finally {
-      await db.end();
-    }
-  }
+			return {
+				alreadyExisted: result.rowCount ? result.rowCount > 0 : false,
+			};
+		} finally {
+			await db.end();
+		}
+	}
 
-  /**
-   * Drops a PostgreSQL database.
-   * Used for cleanup after tests are complete.
-   *
-   * @param uri - PostgreSQL connection URI
-   * @throws Error if database cannot be dropped
-   * @private
-   */
-  private static async drop(uri: string): Promise<void> {
-    const { database, db } = await setupClient(uri);
-    try {
-      await db.connect();
-      await db.query(`DROP DATABASE "${database}"`);
-    } finally {
-      await db.end();
-    }
-  }
+	/**
+	 * Drops a PostgreSQL database.
+	 * Used for cleanup after tests are complete.
+	 *
+	 * @param uri - PostgreSQL connection URI
+	 * @throws Error if database cannot be dropped
+	 * @private
+	 */
+	private static async drop(uri: string): Promise<void> {
+		const { database, db } = await setupClient(uri);
+		try {
+			await db.connect();
+			await db.query(`DROP DATABASE "${database}"`);
+		} finally {
+			await db.end();
+		}
+	}
 
-  /**
-   * Starts the migration process by creating the database and running migrations.
-   * Returns a cleanup function that will drop the database when called.
-   *
-   * @returns Async cleanup function that drops the created database
-   *
-   * @example
-   * ```typescript
-   * const migrator = new MyMigrator('postgresql://localhost:5432/test_db');
-   *
-   * // Start migrations and get cleanup function
-   * const cleanup = await migrator.start();
-   *
-   * try {
-   *   // Run your tests here
-   *   await runTests();
-   * } finally {
-   *   // Always clean up
-   *   await cleanup();
-   * }
-   * ```
-   */
-  async start() {
-    const { database, db } = await setupClient(this.uri);
-    try {
-      await PostgresMigrator.create(this.uri);
-      // Implement migration logic here
-      await this.migrate();
-      logger.log(`Migrating database: ${database}`);
-      // Example: await db.query('CREATE TABLE example (id SERIAL PRIMARY KEY)');
-    } finally {
-      await db.end();
-    }
+	/**
+	 * Starts the migration process by creating the database and running migrations.
+	 * Returns a cleanup function that will drop the database when called.
+	 *
+	 * @returns Async cleanup function that drops the created database
+	 *
+	 * @example
+	 * ```typescript
+	 * const migrator = new MyMigrator('postgresql://localhost:5432/test_db');
+	 *
+	 * // Start migrations and get cleanup function
+	 * const cleanup = await migrator.start();
+	 *
+	 * try {
+	 *   // Run your tests here
+	 *   await runTests();
+	 * } finally {
+	 *   // Always clean up
+	 *   await cleanup();
+	 * }
+	 * ```
+	 */
+	async start() {
+		const { database, db } = await setupClient(this.uri);
+		try {
+			await PostgresMigrator.create(this.uri);
+			// Implement migration logic here
+			await this.migrate();
+			logger.log(`Migrating database: ${database}`);
+			// Example: await db.query('CREATE TABLE example (id SERIAL PRIMARY KEY)');
+		} finally {
+			await db.end();
+		}
 
-    return async () => {
-      await PostgresMigrator.drop(this.uri);
-    };
-  }
+		return async () => {
+			await PostgresMigrator.drop(this.uri);
+		};
+	}
 }

package/src/PostgresObjectionMigrator.ts

@@ -38,101 +38,101 @@ const logger = console;
  * ```
  */
 export class PostgresObjectionMigrator extends PostgresMigrator {
-  /**
-   * Creates a new PostgresObjectionMigrator instance.
-   *
-   * @param options - Configuration options
-   * @param options.uri - PostgreSQL connection URI
-   * @param options.knex - Knex database instance configured with migrations
-   */
-  constructor(
-    private options: {
-      uri: string;
-      knex: Knex;
-    },
-  ) {
-    super(options.uri);
-  }
+	/**
+	 * Creates a new PostgresObjectionMigrator instance.
+	 *
+	 * @param options - Configuration options
+	 * @param options.uri - PostgreSQL connection URI
+	 * @param options.knex - Knex database instance configured with migrations
+	 */
+	constructor(
+		private options: {
+			uri: string;
+			knex: Knex;
+		},
+	) {
+		super(options.uri);
+	}
 
-  /**
-   * Executes Knex migrations to the latest version.
-   * Implements the abstract migrate() method from PostgresMigrator.
-   *
-   * @throws Error if migrations fail to apply
-   * @returns Promise that resolves when all migrations are applied
-   */
-  async migrate(): Promise<void> {
-    try {
-      // Run migrations to latest
-      const [batchNo, migrations] = await this.options.knex.migrate.latest();
+	/**
+	 * Executes Knex migrations to the latest version.
+	 * Implements the abstract migrate() method from PostgresMigrator.
+	 *
+	 * @throws Error if migrations fail to apply
+	 * @returns Promise that resolves when all migrations are applied
+	 */
+	async migrate(): Promise<void> {
+		try {
+			// Run migrations to latest
+			const [batchNo, migrations] = await this.options.knex.migrate.latest();
 
-      if (migrations.length > 0) {
-        logger.log(
-          `Applied batch ${batchNo} with ${migrations.length} migrations:`,
-        );
-        migrations.forEach((migration: string) => {
-          logger.log(`  - ${migration}`);
-        });
-      } else {
-        logger.log('No pending migrations to apply');
-      }
-    } catch (error) {
-      logger.error('Failed to apply migrations:', error);
-      throw error;
-    } finally {
-      // Always destroy the connection pool
-      await this.options.knex.destroy();
-    }
-  }
+			if (migrations.length > 0) {
+				logger.log(
+					`Applied batch ${batchNo} with ${migrations.length} migrations:`,
+				);
+				migrations.forEach((migration: string) => {
+					logger.log(`  - ${migration}`);
+				});
+			} else {
+				logger.log('No pending migrations to apply');
+			}
+		} catch (error) {
+			logger.error('Failed to apply migrations:', error);
+			throw error;
+		} finally {
+			// Always destroy the connection pool
+			await this.options.knex.destroy();
+		}
+	}
 
-  /**
-   * Rolls back the last batch of migrations.
-   * Useful for testing migration rollback scenarios.
-   *
-   * @returns Promise that resolves when rollback is complete
-   */
-  async rollback(): Promise<void> {
-    try {
-      const [batchNo, migrations] = await this.options.knex.migrate.rollback();
+	/**
+	 * Rolls back the last batch of migrations.
+	 * Useful for testing migration rollback scenarios.
+	 *
+	 * @returns Promise that resolves when rollback is complete
+	 */
+	async rollback(): Promise<void> {
+		try {
+			const [batchNo, migrations] = await this.options.knex.migrate.rollback();
 
-      if (migrations.length > 0) {
-        logger.log(
-          `Rolled back batch ${batchNo} with ${migrations.length} migrations:`,
-        );
-        migrations.forEach((migration: string) => {
-          logger.log(`  - ${migration}`);
-        });
-      } else {
-        logger.log('No migrations to rollback');
-      }
-    } catch (error) {
-      logger.error('Failed to rollback migrations:', error);
-      throw error;
-    } finally {
-      await this.options.knex.destroy();
-    }
-  }
+			if (migrations.length > 0) {
+				logger.log(
+					`Rolled back batch ${batchNo} with ${migrations.length} migrations:`,
+				);
+				migrations.forEach((migration: string) => {
+					logger.log(`  - ${migration}`);
+				});
+			} else {
+				logger.log('No migrations to rollback');
+			}
+		} catch (error) {
+			logger.error('Failed to rollback migrations:', error);
+			throw error;
+		} finally {
+			await this.options.knex.destroy();
+		}
+	}
 
-  /**
-   * Gets the current migration status.
-   * Returns information about completed and pending migrations.
-   *
-   * @returns Promise with migration status information
-   */
-  async status(): Promise<{
-    completed: string[];
-    pending: string[];
-  }> {
-    try {
-      const completed = await this.options.knex.migrate.list();
-      const [, pending] = await this.options.knex.migrate.currentVersion();
+	/**
+	 * Gets the current migration status.
+	 * Returns information about completed and pending migrations.
+	 *
+	 * @returns Promise with migration status information
+	 */
+	async status(): Promise<{
+		completed: string[];
+		pending: string[];
+	}> {
+		try {
+			const completed = await this.options.knex.migrate.list();
+			const [, pending] = await this.options.knex.migrate.currentVersion();
 
-      return {
-        completed: Array.isArray(completed[0]) ? completed[0] : [],
-        pending: Array.isArray(pending) ? pending : [],
-      };
-    } finally {
-      await this.options.knex.destroy();
-    }
-  }
+			return {
+				completed: Array.isArray(completed[0]) ? completed[0] : [],
+				pending: Array.isArray(pending) ? pending : [],
+			};
+		} finally {
+			await this.options.knex.destroy();
+		}
+	}
 }

package/src/VitestKyselyTransactionIsolator.ts

@@ -1,7 +1,7 @@
 import type { Kysely, Transaction } from 'kysely';
 import {
-  type IsolationLevel,
-  VitestPostgresTransactionIsolator,
+	type IsolationLevel,
+	VitestPostgresTransactionIsolator,
 } from './VitestTransactionIsolator';
 
 /**
@@ -42,31 +42,31 @@ import {
  * ```
  */
 export class VitestKyselyTransactionIsolator<
-  Database,
+	Database,
 > extends VitestPostgresTransactionIsolator<
-  Kysely<Database>,
-  Transaction<Database>
+	Kysely<Database>,
+	Transaction<Database>
 > {
-  async destroy(conn: Kysely<Database>): Promise<void> {
-    // return conn.destroy();
-  }
-  /**
-   * Creates a Kysely transaction with the specified isolation level.
-   * Implements the abstract transact method from VitestPostgresTransactionIsolator.
-   *
-   * @param conn - The Kysely database connection
-   * @param level - The transaction isolation level
-   * @param fn - The function to execute within the transaction
-   * @returns Promise that resolves when the transaction completes
-   */
-  async transact(
-    conn: Kysely<Database>,
-    level: IsolationLevel,
-    fn: (trx: Transaction<Database>) => Promise<void>,
-  ): Promise<void> {
-    const isolationLevel =
-      level.toLocaleLowerCase() as Lowercase<IsolationLevel>;
-    await conn.transaction().setIsolationLevel(isolationLevel).execute(fn);
-  }
-  // Implement any Kysely-specific transaction logic here
+	async destroy(_conn: Kysely<Database>): Promise<void> {
+		// return conn.destroy();
+	}
+	/**
+	 * Creates a Kysely transaction with the specified isolation level.
+	 * Implements the abstract transact method from VitestPostgresTransactionIsolator.
+	 *
+	 * @param conn - The Kysely database connection
+	 * @param level - The transaction isolation level
+	 * @param fn - The function to execute within the transaction
+	 * @returns Promise that resolves when the transaction completes
+	 */
+	async transact(
+		conn: Kysely<Database>,
+		level: IsolationLevel,
+		fn: (trx: Transaction<Database>) => Promise<void>,
+	): Promise<void> {
+		const isolationLevel =
+			level.toLocaleLowerCase() as Lowercase<IsolationLevel>;
+		await conn.transaction().setIsolationLevel(isolationLevel).execute(fn);
+	}
+	// Implement any Kysely-specific transaction logic here
 }