@geekmidas/testkit 0.0.7 → 0.0.9

package/dist/__tests__/integration.spec.mjs

@@ -3,11 +3,11 @@ import "../faker-CxKkEeYi.mjs";
 import { KyselyFactory } from "../KyselyFactory-ELiHgHVv.mjs";
 import "../PostgresMigrator-BzqksJcW.mjs";
 import "../PostgresKyselyMigrator-ChIpZFYB.mjs";
-import "../VitestTransactionIsolator-kFL36T8x.mjs";
-import "../VitestKyselyTransactionIsolator-AfxPJEwR.mjs";
-import { createKyselyDb } from "../helpers-CKMlwSYT.mjs";
-import { wrapVitestKyselyTransaction } from "../kysely-CqfoKVXs.mjs";
-import { TEST_DATABASE_CONFIG, createTestTables } from "../helpers-CukcFAU9.mjs";
+import "../VitestTransactionIsolator-BWwK-ca6.mjs";
+import "../VitestKyselyTransactionIsolator-BKGT9nEG.mjs";
+import { createKyselyDb } from "../helpers-BuPmgzyQ.mjs";
+import { wrapVitestKyselyTransaction } from "../kysely-Cx_1pZYc.mjs";
+import { TEST_DATABASE_CONFIG, createTestTables } from "../helpers-BEmjyUVE.mjs";
 import { beforeAll, describe, expect, it } from "vitest";
 
 //#region src/__tests__/integration.spec.ts

package/dist/{helpers-CukcFAU9.mjs → helpers-BEmjyUVE.mjs}

@@ -108,4 +108,4 @@ async function createTestDatabase(dbName) {
 }
 
 //#endregion
-export { TEST_DATABASE_CONFIG, createTestDatabase, createTestTables, setupKnexTest };
+export { TEST_DATABASE_CONFIG, createKnexDb, createTestDatabase, createTestTables, createTestTablesKnex, setupKnexTest };

package/dist/{helpers-Bnm3Jy9X.cjs → helpers-CNMBePuj.cjs}

@@ -115,6 +115,12 @@ Object.defineProperty(exports, 'TEST_DATABASE_CONFIG', {
     return TEST_DATABASE_CONFIG;
   }
 });
+Object.defineProperty(exports, 'createKnexDb', {
+  enumerable: true,
+  get: function () {
+    return createKnexDb;
+  }
+});
 Object.defineProperty(exports, 'createTestDatabase', {
   enumerable: true,
   get: function () {
@@ -127,6 +133,12 @@ Object.defineProperty(exports, 'createTestTables', {
     return createTestTables;
   }
 });
+Object.defineProperty(exports, 'createTestTablesKnex', {
+  enumerable: true,
+  get: function () {
+    return createTestTablesKnex;
+  }
+});
 Object.defineProperty(exports, 'setupKnexTest', {
   enumerable: true,
   get: function () {

package/dist/helpers.cjs

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

package/dist/helpers.mjs

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

package/dist/{kysely-B-GOhABm.cjs → kysely-CBfCXxUn.cjs}

@@ -1,5 +1,5 @@
-const require_VitestTransactionIsolator = require('./VitestTransactionIsolator-DcOz0LZF.cjs');
-const require_VitestKyselyTransactionIsolator = require('./VitestKyselyTransactionIsolator-YWnSJiIH.cjs');
+const require_VitestTransactionIsolator = require('./VitestTransactionIsolator-CruLTRRi.cjs');
+const require_VitestKyselyTransactionIsolator = require('./VitestKyselyTransactionIsolator-CIlpIO78.cjs');
 
 //#region src/kysely.ts
 /**

package/dist/{kysely-CqfoKVXs.mjs → kysely-Cx_1pZYc.mjs}

@@ -1,5 +1,5 @@
-import { IsolationLevel } from "./VitestTransactionIsolator-kFL36T8x.mjs";
-import { VitestKyselyTransactionIsolator } from "./VitestKyselyTransactionIsolator-AfxPJEwR.mjs";
+import { IsolationLevel } from "./VitestTransactionIsolator-BWwK-ca6.mjs";
+import { VitestKyselyTransactionIsolator } from "./VitestKyselyTransactionIsolator-BKGT9nEG.mjs";
 
 //#region src/kysely.ts
 /**

package/dist/kysely.cjs

@@ -3,9 +3,9 @@ require('./faker-SMN4ira4.cjs');
 const require_KyselyFactory = require('./KyselyFactory-Bdq1s1Go.cjs');
 require('./PostgresMigrator-BtAWdLss.cjs');
 const require_PostgresKyselyMigrator = require('./PostgresKyselyMigrator-Bs31emFd.cjs');
-const require_VitestTransactionIsolator = require('./VitestTransactionIsolator-DcOz0LZF.cjs');
-const require_VitestKyselyTransactionIsolator = require('./VitestKyselyTransactionIsolator-YWnSJiIH.cjs');
-const require_kysely = require('./kysely-B-GOhABm.cjs');
+const require_VitestTransactionIsolator = require('./VitestTransactionIsolator-CruLTRRi.cjs');
+const require_VitestKyselyTransactionIsolator = require('./VitestKyselyTransactionIsolator-CIlpIO78.cjs');
+const require_kysely = require('./kysely-CBfCXxUn.cjs');
 
 exports.IsolationLevel = require_VitestTransactionIsolator.IsolationLevel;
 exports.KyselyFactory = require_KyselyFactory.KyselyFactory;

package/dist/kysely.mjs

@@ -3,8 +3,8 @@ import "./faker-CxKkEeYi.mjs";
 import { KyselyFactory } from "./KyselyFactory-ELiHgHVv.mjs";
 import "./PostgresMigrator-BzqksJcW.mjs";
 import { PostgresKyselyMigrator } from "./PostgresKyselyMigrator-ChIpZFYB.mjs";
-import { IsolationLevel } from "./VitestTransactionIsolator-kFL36T8x.mjs";
-import { VitestKyselyTransactionIsolator } from "./VitestKyselyTransactionIsolator-AfxPJEwR.mjs";
-import { wrapVitestKyselyTransaction } from "./kysely-CqfoKVXs.mjs";
+import { IsolationLevel } from "./VitestTransactionIsolator-BWwK-ca6.mjs";
+import { VitestKyselyTransactionIsolator } from "./VitestKyselyTransactionIsolator-BKGT9nEG.mjs";
+import { wrapVitestKyselyTransaction } from "./kysely-Cx_1pZYc.mjs";
 
 export { IsolationLevel, KyselyFactory, PostgresKyselyMigrator, VitestKyselyTransactionIsolator, wrapVitestKyselyTransaction };

package/dist/objection-CCD8fMLj.cjs

@@ -0,0 +1,87 @@
+const require_VitestTransactionIsolator = require('./VitestTransactionIsolator-CruLTRRi.cjs');
+const require_VitestObjectionTransactionIsolator = require('./VitestObjectionTransactionIsolator-DyqLp_in.cjs');
+
+//#region src/objection.ts
+/**
+* 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.
+*
+* @param api - The Vitest test API (usually `test` from vitest)
+* @param knex - The Knex database connection 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 { wrapVitestObjectionTransaction } from '@geekmidas/testkit/objection';
+* import { knex } from './database';
+* import { User, Post } from './models';
+*
+* // Create isolated test with automatic rollback
+* const isolatedTest = wrapVitestObjectionTransaction(test, 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();
+*   // User is automatically rolled back after test
+* });
+*
+* // With setup function for common test data
+* const testWithSetup = wrapVitestObjectionTransaction(
+*   test,
+*   knex,
+*   async (trx) => {
+*     // Create common test data
+*     await knex('settings')
+*       .transacting(trx)
+*       .insert({ key: 'test_mode', value: 'true' });
+*   }
+* );
+*
+* testWithSetup('should have test settings', async ({ trx }) => {
+*   const setting = await knex('settings')
+*     .transacting(trx)
+*     .where('key', 'test_mode')
+*     .first();
+*
+*   expect(setting?.value).toBe('true');
+* });
+*
+* // Example with factory and transaction
+* const isolatedTest = wrapVitestObjectionTransaction(test, knex);
+* const factory = new ObjectionFactory(builders, seeds, knex);
+*
+* isolatedTest('creates related data', async ({ trx }) => {
+*   // Factory can use the transaction
+*   const user = await User.query(trx).insert({ name: 'Author' });
+*   const posts = await Post.query(trx).insert([
+*     { title: 'Post 1', userId: user.id },
+*     { title: 'Post 2', userId: user.id }
+*   ]);
+*
+*   const userWithPosts = await User.query(trx)
+*     .findById(user.id)
+*     .withGraphFetched('posts');
+*
+*   expect(userWithPosts.posts).toHaveLength(2);
+* });
+* ```
+*/
+function wrapVitestObjectionTransaction(api, knex, setup, level = require_VitestTransactionIsolator.IsolationLevel.REPEATABLE_READ) {
+	const wrapper = new require_VitestObjectionTransactionIsolator.VitestObjectionTransactionIsolator(api);
+	return wrapper.wrapVitestWithTransaction(knex, setup, level);
+}
+
+//#endregion
+Object.defineProperty(exports, 'wrapVitestObjectionTransaction', {
+  enumerable: true,
+  get: function () {
+    return wrapVitestObjectionTransaction;
+  }
+});

package/dist/objection-lsMgM5gP.mjs

@@ -0,0 +1,82 @@
+import { IsolationLevel } from "./VitestTransactionIsolator-BWwK-ca6.mjs";
+import { VitestObjectionTransactionIsolator } from "./VitestObjectionTransactionIsolator-BPoLUFop.mjs";
+
+//#region src/objection.ts
+/**
+* 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.
+*
+* @param api - The Vitest test API (usually `test` from vitest)
+* @param knex - The Knex database connection 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 { wrapVitestObjectionTransaction } from '@geekmidas/testkit/objection';
+* import { knex } from './database';
+* import { User, Post } from './models';
+*
+* // Create isolated test with automatic rollback
+* const isolatedTest = wrapVitestObjectionTransaction(test, 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();
+*   // User is automatically rolled back after test
+* });
+*
+* // With setup function for common test data
+* const testWithSetup = wrapVitestObjectionTransaction(
+*   test,
+*   knex,
+*   async (trx) => {
+*     // Create common test data
+*     await knex('settings')
+*       .transacting(trx)
+*       .insert({ key: 'test_mode', value: 'true' });
+*   }
+* );
+*
+* testWithSetup('should have test settings', async ({ trx }) => {
+*   const setting = await knex('settings')
+*     .transacting(trx)
+*     .where('key', 'test_mode')
+*     .first();
+*
+*   expect(setting?.value).toBe('true');
+* });
+*
+* // Example with factory and transaction
+* const isolatedTest = wrapVitestObjectionTransaction(test, knex);
+* const factory = new ObjectionFactory(builders, seeds, knex);
+*
+* isolatedTest('creates related data', async ({ trx }) => {
+*   // Factory can use the transaction
+*   const user = await User.query(trx).insert({ name: 'Author' });
+*   const posts = await Post.query(trx).insert([
+*     { title: 'Post 1', userId: user.id },
+*     { title: 'Post 2', userId: user.id }
+*   ]);
+*
+*   const userWithPosts = await User.query(trx)
+*     .findById(user.id)
+*     .withGraphFetched('posts');
+*
+*   expect(userWithPosts.posts).toHaveLength(2);
+* });
+* ```
+*/
+function wrapVitestObjectionTransaction(api, knex, setup, level = IsolationLevel.REPEATABLE_READ) {
+	const wrapper = new VitestObjectionTransactionIsolator(api);
+	return wrapper.wrapVitestWithTransaction(knex, setup, level);
+}
+
+//#endregion
+export { wrapVitestObjectionTransaction };

package/dist/objection.cjs

@@ -1,87 +1,13 @@
 require('./Factory-WMhTNZ9S.cjs');
 const require_ObjectionFactory = require('./ObjectionFactory-C47B03Ot.cjs');
-const require_VitestTransactionIsolator = require('./VitestTransactionIsolator-DcOz0LZF.cjs');
-const require_VitestObjectionTransactionIsolator = require('./VitestObjectionTransactionIsolator-0uX6DW5G.cjs');
+require('./PostgresMigrator-BtAWdLss.cjs');
+const require_PostgresObjectionMigrator = require('./PostgresObjectionMigrator-B88aTT0m.cjs');
+const require_VitestTransactionIsolator = require('./VitestTransactionIsolator-CruLTRRi.cjs');
+const require_VitestObjectionTransactionIsolator = require('./VitestObjectionTransactionIsolator-DyqLp_in.cjs');
+const require_objection = require('./objection-CCD8fMLj.cjs');
 
-//#region src/objection.ts
-/**
-* 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.
-*
-* @param api - The Vitest test API (usually `test` from vitest)
-* @param knex - The Knex database connection 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 { wrapVitestObjectionTransaction } from '@geekmidas/testkit/objection';
-* import { knex } from './database';
-* import { User, Post } from './models';
-*
-* // Create isolated test with automatic rollback
-* const isolatedTest = wrapVitestObjectionTransaction(test, 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();
-*   // User is automatically rolled back after test
-* });
-*
-* // With setup function for common test data
-* const testWithSetup = wrapVitestObjectionTransaction(
-*   test,
-*   knex,
-*   async (trx) => {
-*     // Create common test data
-*     await knex('settings')
-*       .transacting(trx)
-*       .insert({ key: 'test_mode', value: 'true' });
-*   }
-* );
-*
-* testWithSetup('should have test settings', async ({ trx }) => {
-*   const setting = await knex('settings')
-*     .transacting(trx)
-*     .where('key', 'test_mode')
-*     .first();
-*
-*   expect(setting?.value).toBe('true');
-* });
-*
-* // Example with factory and transaction
-* const isolatedTest = wrapVitestObjectionTransaction(test, knex);
-* const factory = new ObjectionFactory(builders, seeds, knex);
-*
-* isolatedTest('creates related data', async ({ trx }) => {
-*   // Factory can use the transaction
-*   const user = await User.query(trx).insert({ name: 'Author' });
-*   const posts = await Post.query(trx).insert([
-*     { title: 'Post 1', userId: user.id },
-*     { title: 'Post 2', userId: user.id }
-*   ]);
-*
-*   const userWithPosts = await User.query(trx)
-*     .findById(user.id)
-*     .withGraphFetched('posts');
-*
-*   expect(userWithPosts.posts).toHaveLength(2);
-* });
-* ```
-*/
-function wrapVitestObjectionTransaction(api, knex, setup, level = require_VitestTransactionIsolator.IsolationLevel.REPEATABLE_READ) {
-	const wrapper = new require_VitestObjectionTransactionIsolator.VitestObjectionTransactionIsolator(api);
-	return wrapper.wrapVitestWithTransaction(knex, setup, level);
-}
-
-//#endregion
 exports.IsolationLevel = require_VitestTransactionIsolator.IsolationLevel;
 exports.ObjectionFactory = require_ObjectionFactory.ObjectionFactory;
+exports.PostgresObjectionMigrator = require_PostgresObjectionMigrator.PostgresObjectionMigrator;
 exports.VitestObjectionTransactionIsolator = require_VitestObjectionTransactionIsolator.VitestObjectionTransactionIsolator;
-exports.wrapVitestObjectionTransaction = wrapVitestObjectionTransaction;
+exports.wrapVitestObjectionTransaction = require_objection.wrapVitestObjectionTransaction;

package/dist/objection.mjs

@@ -1,84 +1,9 @@
 import "./Factory-z2m01hMj.mjs";
 import { ObjectionFactory } from "./ObjectionFactory-89p-FFEw.mjs";
-import { IsolationLevel } from "./VitestTransactionIsolator-kFL36T8x.mjs";
-import { VitestObjectionTransactionIsolator } from "./VitestObjectionTransactionIsolator-BZRYy8iW.mjs";
+import "./PostgresMigrator-BzqksJcW.mjs";
+import { PostgresObjectionMigrator } from "./PostgresObjectionMigrator-DydSgYFv.mjs";
+import { IsolationLevel } from "./VitestTransactionIsolator-BWwK-ca6.mjs";
+import { VitestObjectionTransactionIsolator } from "./VitestObjectionTransactionIsolator-BPoLUFop.mjs";
+import { wrapVitestObjectionTransaction } from "./objection-lsMgM5gP.mjs";
 
-//#region src/objection.ts
-/**
-* 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.
-*
-* @param api - The Vitest test API (usually `test` from vitest)
-* @param knex - The Knex database connection 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 { wrapVitestObjectionTransaction } from '@geekmidas/testkit/objection';
-* import { knex } from './database';
-* import { User, Post } from './models';
-*
-* // Create isolated test with automatic rollback
-* const isolatedTest = wrapVitestObjectionTransaction(test, 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();
-*   // User is automatically rolled back after test
-* });
-*
-* // With setup function for common test data
-* const testWithSetup = wrapVitestObjectionTransaction(
-*   test,
-*   knex,
-*   async (trx) => {
-*     // Create common test data
-*     await knex('settings')
-*       .transacting(trx)
-*       .insert({ key: 'test_mode', value: 'true' });
-*   }
-* );
-*
-* testWithSetup('should have test settings', async ({ trx }) => {
-*   const setting = await knex('settings')
-*     .transacting(trx)
-*     .where('key', 'test_mode')
-*     .first();
-*
-*   expect(setting?.value).toBe('true');
-* });
-*
-* // Example with factory and transaction
-* const isolatedTest = wrapVitestObjectionTransaction(test, knex);
-* const factory = new ObjectionFactory(builders, seeds, knex);
-*
-* isolatedTest('creates related data', async ({ trx }) => {
-*   // Factory can use the transaction
-*   const user = await User.query(trx).insert({ name: 'Author' });
-*   const posts = await Post.query(trx).insert([
-*     { title: 'Post 1', userId: user.id },
-*     { title: 'Post 2', userId: user.id }
-*   ]);
-*
-*   const userWithPosts = await User.query(trx)
-*     .findById(user.id)
-*     .withGraphFetched('posts');
-*
-*   expect(userWithPosts.posts).toHaveLength(2);
-* });
-* ```
-*/
-function wrapVitestObjectionTransaction(api, knex, setup, level = IsolationLevel.REPEATABLE_READ) {
-	const wrapper = new VitestObjectionTransactionIsolator(api);
-	return wrapper.wrapVitestWithTransaction(knex, setup, level);
-}
-
-//#endregion
-export { IsolationLevel, ObjectionFactory, VitestObjectionTransactionIsolator, wrapVitestObjectionTransaction };
+export { IsolationLevel, ObjectionFactory, PostgresObjectionMigrator, VitestObjectionTransactionIsolator, wrapVitestObjectionTransaction };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@geekmidas/testkit",
-  "version": "0.0.7",
+  "version": "0.0.9",
   "private": false,
   "type": "module",
   "exports": {

package/src/PostgresObjectionMigrator.ts

@@ -0,0 +1,138 @@
+import type { Knex } from 'knex';
+import { PostgresMigrator } from './PostgresMigrator';
+
+/**
+ * Default logger instance for migration operations.
+ */
+const logger = console;
+
+/**
+ * PostgreSQL migrator implementation for Objection.js ORM with Knex.
+ * Extends PostgresMigrator to provide Knex-specific migration functionality.
+ * Automatically creates test databases and applies migrations for testing environments.
+ *
+ * @example
+ * ```typescript
+ * import knex from 'knex';
+ * import { PostgresObjectionMigrator } from '@geekmidas/testkit';
+ *
+ * // Create Knex instance
+ * const db = knex({
+ *   client: 'pg',
+ *   connection: uri,
+ *   migrations: {
+ *     directory: path.join(__dirname, 'migrations'),
+ *     extension: 'ts'
+ *   }
+ * });
+ *
+ * // Create and use migrator
+ * const migrator = new PostgresObjectionMigrator({
+ *   uri: 'postgresql://localhost:5432/test_db',
+ *   knex: db
+ * });
+ *
+ * const cleanup = await migrator.start();
+ * // Run tests...
+ * await cleanup();
+ * ```
+ */
+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);
+  }
+
+  /**
+   * 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();
+    }
+  }
+
+  /**
+   * 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();
+    }
+  }
+
+  /**
+   * 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();
+    }
+  }
+}

package/src/VitestObjectionTransactionIsolator.ts

@@ -60,7 +60,8 @@ export class VitestObjectionTransactionIsolator extends VitestPostgresTransactio
     level: IsolationLevel,
     fn: (trx: Knex.Transaction) => Promise<void>,
   ): Promise<void> {
-    const isolationLevel = level.toUpperCase() as Lowercase<IsolationLevel>;
+    const isolationLevel = level.toLowerCase() as Lowercase<IsolationLevel>;
+
     await conn.transaction(
       async (trx) => {
         await fn(trx);