@geekmidas/testkit 0.0.5 → 0.0.7

package/dist/PostgresMigrator-BtAWdLss.cjs

@@ -0,0 +1,151 @@
+const require_chunk = require('./chunk-CUT6urMc.cjs');
+const pg = require_chunk.__toESM(require("pg"));
+
+//#region src/PostgresMigrator.ts
+/**
+* Creates a PostgreSQL client connected to the 'postgres' database.
+* Extracts connection details from the provided URI.
+*
+* @param uri - PostgreSQL connection URI
+* @returns Object containing the target database name and client instance
+*
+* @example
+* ```typescript
+* const { database, db } = await setupClient('postgresql://user:pass@localhost:5432/mydb');
+* // database = 'mydb'
+* // db = Client instance connected to 'postgres' database
+* ```
+*/
+async function setupClient(uri) {
+	const url = new URL(uri);
+	const db = new pg.Client({
+		user: url.username,
+		password: url.password,
+		host: url.hostname,
+		port: parseInt(url.port),
+		database: "postgres"
+	});
+	let database = url.pathname.slice(1);
+	if (database.includes("?")) database = database.substring(0, database.indexOf("?"));
+	return {
+		database,
+		db
+	};
+}
+/**
+* Default logger instance for migration operations.
+*/
+const logger = console;
+/**
+* Abstract base class for PostgreSQL database migration utilities.
+* Provides database creation, migration, and cleanup functionality for testing.
+* Subclasses must implement the migrate() method to define migration logic.
+*
+* @example
+* ```typescript
+* class MyMigrator extends PostgresMigrator {
+*   async migrate(): Promise<void> {
+*     // Run your migrations here
+*     await this.runMigrations();
+*   }
+* }
+*
+* // Use in tests
+* const migrator = new MyMigrator('postgresql://localhost:5432/test_db');
+* const cleanup = await migrator.start();
+*
+* // Run tests...
+*
+* // Clean up
+* await cleanup();
+* ```
+*/
+var PostgresMigrator = class PostgresMigrator {
+	/**
+	* Creates a new PostgresMigrator instance.
+	*
+	* @param uri - PostgreSQL connection URI
+	*/
+	constructor(uri) {
+		this.uri = uri;
+	}
+	/**
+	* 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
+	*/
+	static async create(uri) {
+		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}"`);
+			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
+	*/
+	static async drop(uri) {
+		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);
+			await this.migrate();
+			logger.log(`Migrating database: ${database}`);
+		} finally {
+			await db.end();
+		}
+		return async () => {
+			await PostgresMigrator.drop(this.uri);
+		};
+	}
+};
+
+//#endregion
+Object.defineProperty(exports, 'PostgresMigrator', {
+  enumerable: true,
+  get: function () {
+    return PostgresMigrator;
+  }
+});

package/dist/PostgresMigrator-BzqksJcW.mjs

@@ -0,0 +1,145 @@
+import { Client } from "pg";
+
+//#region src/PostgresMigrator.ts
+/**
+* Creates a PostgreSQL client connected to the 'postgres' database.
+* Extracts connection details from the provided URI.
+*
+* @param uri - PostgreSQL connection URI
+* @returns Object containing the target database name and client instance
+*
+* @example
+* ```typescript
+* const { database, db } = await setupClient('postgresql://user:pass@localhost:5432/mydb');
+* // database = 'mydb'
+* // db = Client instance connected to 'postgres' database
+* ```
+*/
+async function setupClient(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"
+	});
+	let database = url.pathname.slice(1);
+	if (database.includes("?")) database = database.substring(0, database.indexOf("?"));
+	return {
+		database,
+		db
+	};
+}
+/**
+* Default logger instance for migration operations.
+*/
+const logger = console;
+/**
+* Abstract base class for PostgreSQL database migration utilities.
+* Provides database creation, migration, and cleanup functionality for testing.
+* Subclasses must implement the migrate() method to define migration logic.
+*
+* @example
+* ```typescript
+* class MyMigrator extends PostgresMigrator {
+*   async migrate(): Promise<void> {
+*     // Run your migrations here
+*     await this.runMigrations();
+*   }
+* }
+*
+* // Use in tests
+* const migrator = new MyMigrator('postgresql://localhost:5432/test_db');
+* const cleanup = await migrator.start();
+*
+* // Run tests...
+*
+* // Clean up
+* await cleanup();
+* ```
+*/
+var PostgresMigrator = class PostgresMigrator {
+	/**
+	* Creates a new PostgresMigrator instance.
+	*
+	* @param uri - PostgreSQL connection URI
+	*/
+	constructor(uri) {
+		this.uri = uri;
+	}
+	/**
+	* 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
+	*/
+	static async create(uri) {
+		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}"`);
+			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
+	*/
+	static async drop(uri) {
+		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);
+			await this.migrate();
+			logger.log(`Migrating database: ${database}`);
+		} finally {
+			await db.end();
+		}
+		return async () => {
+			await PostgresMigrator.drop(this.uri);
+		};
+	}
+};
+
+//#endregion
+export { PostgresMigrator };

package/dist/PostgresMigrator.cjs

@@ -1,3 +1,3 @@
-const require_PostgresMigrator = require('./PostgresMigrator-Bz-tnjB6.cjs');
+const require_PostgresMigrator = require('./PostgresMigrator-BtAWdLss.cjs');
 
 exports.PostgresMigrator = require_PostgresMigrator.PostgresMigrator;

package/dist/PostgresMigrator.mjs

@@ -1,3 +1,3 @@
-import { PostgresMigrator } from "./PostgresMigrator-CEoRKTdq.mjs";
+import { PostgresMigrator } from "./PostgresMigrator-BzqksJcW.mjs";
 
 export { PostgresMigrator };

package/dist/VitestKyselyTransactionIsolator-AfxPJEwR.mjs

@@ -0,0 +1,58 @@
+import { VitestPostgresTransactionIsolator } from "./VitestTransactionIsolator-kFL36T8x.mjs";
+
+//#region src/VitestKyselyTransactionIsolator.ts
+/**
+* Kysely-specific implementation of the Vitest transaction isolator.
+* Provides automatic transaction rollback for test isolation using Kysely's transaction API.
+* Each test runs within a database transaction that is rolled back after completion,
+* ensuring a clean state between tests without the overhead of recreating data.
+*
+* @template Database - The database schema type
+*
+* @example
+* ```typescript
+* import { VitestKyselyTransactionIsolator } from '@geekmidas/testkit';
+* import { db } from './database';
+*
+* // Create isolator instance
+* const isolator = new VitestKyselyTransactionIsolator<Database>();
+*
+* // In your test setup
+* beforeEach(async () => {
+*   await isolator.start(db);
+* });
+*
+* afterEach(async () => {
+*   await isolator.rollback();
+* });
+*
+* // Tests run in isolated transactions
+* it('should create user', async () => {
+*   const user = await db.insertInto('users')
+*     .values({ name: 'Test User' })
+*     .returningAll()
+*     .executeTakeFirst();
+*
+*   expect(user).toBeDefined();
+*   // This data will be rolled back after the test
+* });
+* ```
+*/
+var VitestKyselyTransactionIsolator = class extends VitestPostgresTransactionIsolator {
+	/**
+	* 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, level, fn) {
+		const isolationLevel = level.toLocaleLowerCase();
+		await conn.transaction().setIsolationLevel(isolationLevel).execute(fn);
+	}
+};
+
+//#endregion
+export { VitestKyselyTransactionIsolator };

package/dist/VitestKyselyTransactionIsolator-YWnSJiIH.cjs

@@ -0,0 +1,63 @@
+const require_VitestTransactionIsolator = require('./VitestTransactionIsolator-DcOz0LZF.cjs');
+
+//#region src/VitestKyselyTransactionIsolator.ts
+/**
+* Kysely-specific implementation of the Vitest transaction isolator.
+* Provides automatic transaction rollback for test isolation using Kysely's transaction API.
+* Each test runs within a database transaction that is rolled back after completion,
+* ensuring a clean state between tests without the overhead of recreating data.
+*
+* @template Database - The database schema type
+*
+* @example
+* ```typescript
+* import { VitestKyselyTransactionIsolator } from '@geekmidas/testkit';
+* import { db } from './database';
+*
+* // Create isolator instance
+* const isolator = new VitestKyselyTransactionIsolator<Database>();
+*
+* // In your test setup
+* beforeEach(async () => {
+*   await isolator.start(db);
+* });
+*
+* afterEach(async () => {
+*   await isolator.rollback();
+* });
+*
+* // Tests run in isolated transactions
+* it('should create user', async () => {
+*   const user = await db.insertInto('users')
+*     .values({ name: 'Test User' })
+*     .returningAll()
+*     .executeTakeFirst();
+*
+*   expect(user).toBeDefined();
+*   // This data will be rolled back after the test
+* });
+* ```
+*/
+var VitestKyselyTransactionIsolator = class extends require_VitestTransactionIsolator.VitestPostgresTransactionIsolator {
+	/**
+	* 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, level, fn) {
+		const isolationLevel = level.toLocaleLowerCase();
+		await conn.transaction().setIsolationLevel(isolationLevel).execute(fn);
+	}
+};
+
+//#endregion
+Object.defineProperty(exports, 'VitestKyselyTransactionIsolator', {
+  enumerable: true,
+  get: function () {
+    return VitestKyselyTransactionIsolator;
+  }
+});

package/dist/VitestKyselyTransactionIsolator.cjs

@@ -1,4 +1,4 @@
-require('./VitestTransactionIsolator-Bx2c4OzK.cjs');
-const require_VitestKyselyTransactionIsolator = require('./VitestKyselyTransactionIsolator-DWSTKIe3.cjs');
+require('./VitestTransactionIsolator-DcOz0LZF.cjs');
+const require_VitestKyselyTransactionIsolator = require('./VitestKyselyTransactionIsolator-YWnSJiIH.cjs');
 
 exports.VitestKyselyTransactionIsolator = require_VitestKyselyTransactionIsolator.VitestKyselyTransactionIsolator;

package/dist/VitestKyselyTransactionIsolator.mjs

@@ -1,4 +1,4 @@
-import "./VitestTransactionIsolator-BjVXqFs6.mjs";
-import { VitestKyselyTransactionIsolator } from "./VitestKyselyTransactionIsolator-BS3R-V0I.mjs";
+import "./VitestTransactionIsolator-kFL36T8x.mjs";
+import { VitestKyselyTransactionIsolator } from "./VitestKyselyTransactionIsolator-AfxPJEwR.mjs";
 
 export { VitestKyselyTransactionIsolator };

package/dist/VitestObjectionTransactionIsolator-0uX6DW5G.cjs

@@ -0,0 +1,66 @@
+const require_VitestTransactionIsolator = require('./VitestTransactionIsolator-DcOz0LZF.cjs');
+
+//#region src/VitestObjectionTransactionIsolator.ts
+/**
+* Objection.js-specific implementation of the Vitest transaction isolator.
+* Provides automatic transaction rollback for test isolation using Objection.js and Knex transaction API.
+* Each test runs within a database transaction that is rolled back after completion,
+* ensuring a clean state between tests without the overhead of recreating data.
+*
+* @example
+* ```typescript
+* import { VitestObjectionTransactionIsolator } from '@geekmidas/testkit';
+* import { knex } from './database';
+* import { User } from './models';
+* import { test } from 'vitest';
+*
+* // Create isolator instance
+* const isolator = new VitestObjectionTransactionIsolator(test);
+*
+* // Use with wrapped test API
+* const isolatedTest = isolator.wrapVitestWithTransaction(knex);
+*
+* isolatedTest('should create user', async ({ trx }) => {
+*   const user = await User.query(trx)
+*     .insert({ name: 'Test User' });
+*
+*   expect(user).toBeDefined();
+*   // This data will be rolled back after the test
+* });
+* ```
+*/
+var VitestObjectionTransactionIsolator = class extends require_VitestTransactionIsolator.VitestPostgresTransactionIsolator {
+	/**
+	* Creates a Knex transaction with the specified isolation level.
+	* Implements the abstract transact method from VitestPostgresTransactionIsolator.
+	* This transaction can be used with Objection.js models via Model.query(trx).
+	*
+	* @param conn - The Knex 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
+	*
+	* @example
+	* ```typescript
+	* await isolator.transact(knex, IsolationLevel.REPEATABLE_READ, async (trx) => {
+	*   // Use transaction with Objection models
+	*   await User.query(trx).insert({ name: 'Test' });
+	*   await Post.query(trx).where('userId', user.id).delete();
+	* });
+	* ```
+	*/
+	async transact(conn, level, fn) {
+		const isolationLevel = level.toUpperCase();
+		await conn.transaction(async (trx) => {
+			await fn(trx);
+		}, { isolationLevel });
+	}
+};
+
+//#endregion
+Object.defineProperty(exports, 'VitestObjectionTransactionIsolator', {
+  enumerable: true,
+  get: function () {
+    return VitestObjectionTransactionIsolator;
+  }
+});

package/dist/VitestObjectionTransactionIsolator-BZRYy8iW.mjs

@@ -0,0 +1,61 @@
+import { VitestPostgresTransactionIsolator } from "./VitestTransactionIsolator-kFL36T8x.mjs";
+
+//#region src/VitestObjectionTransactionIsolator.ts
+/**
+* Objection.js-specific implementation of the Vitest transaction isolator.
+* Provides automatic transaction rollback for test isolation using Objection.js and Knex transaction API.
+* Each test runs within a database transaction that is rolled back after completion,
+* ensuring a clean state between tests without the overhead of recreating data.
+*
+* @example
+* ```typescript
+* import { VitestObjectionTransactionIsolator } from '@geekmidas/testkit';
+* import { knex } from './database';
+* import { User } from './models';
+* import { test } from 'vitest';
+*
+* // Create isolator instance
+* const isolator = new VitestObjectionTransactionIsolator(test);
+*
+* // Use with wrapped test API
+* const isolatedTest = isolator.wrapVitestWithTransaction(knex);
+*
+* isolatedTest('should create user', async ({ trx }) => {
+*   const user = await User.query(trx)
+*     .insert({ name: 'Test User' });
+*
+*   expect(user).toBeDefined();
+*   // This data will be rolled back after the test
+* });
+* ```
+*/
+var VitestObjectionTransactionIsolator = class extends VitestPostgresTransactionIsolator {
+	/**
+	* Creates a Knex transaction with the specified isolation level.
+	* Implements the abstract transact method from VitestPostgresTransactionIsolator.
+	* This transaction can be used with Objection.js models via Model.query(trx).
+	*
+	* @param conn - The Knex 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
+	*
+	* @example
+	* ```typescript
+	* await isolator.transact(knex, IsolationLevel.REPEATABLE_READ, async (trx) => {
+	*   // Use transaction with Objection models
+	*   await User.query(trx).insert({ name: 'Test' });
+	*   await Post.query(trx).where('userId', user.id).delete();
+	* });
+	* ```
+	*/
+	async transact(conn, level, fn) {
+		const isolationLevel = level.toUpperCase();
+		await conn.transaction(async (trx) => {
+			await fn(trx);
+		}, { isolationLevel });
+	}
+};
+
+//#endregion
+export { VitestObjectionTransactionIsolator };

package/dist/VitestObjectionTransactionIsolator.cjs

@@ -0,0 +1,4 @@
+require('./VitestTransactionIsolator-DcOz0LZF.cjs');
+const require_VitestObjectionTransactionIsolator = require('./VitestObjectionTransactionIsolator-0uX6DW5G.cjs');
+
+exports.VitestObjectionTransactionIsolator = require_VitestObjectionTransactionIsolator.VitestObjectionTransactionIsolator;

package/dist/VitestObjectionTransactionIsolator.mjs

@@ -0,0 +1,4 @@
+import "./VitestTransactionIsolator-kFL36T8x.mjs";
+import { VitestObjectionTransactionIsolator } from "./VitestObjectionTransactionIsolator-BZRYy8iW.mjs";
+
+export { VitestObjectionTransactionIsolator };