@geekmidas/testkit 10.0.0-alpha.4 → 10.0.0-alpha.40

package/dist/VitestKyselyTransactionIsolator.cjs

@@ -1,4 +1,67 @@
-require('./VitestTransactionIsolator-DyiX-QtK.cjs');
-const require_VitestKyselyTransactionIsolator = require('./VitestKyselyTransactionIsolator-BjJSXryR.cjs');
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_VitestTransactionIsolator = require("./VitestTransactionIsolator.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 {
+	/**
+	* Closes the pool. Safe to implement now that it runs in the file's
+	* teardown rather than after every test, where it would have closed the
+	* connection the next test was about to use.
+	*/
+	async destroy(conn) {
+		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, level, fn) {
+		const isolationLevel = level.toLocaleLowerCase();
+		await conn.transaction().setIsolationLevel(isolationLevel).execute(fn);
+	}
+};
+//#endregion
+exports.VitestKyselyTransactionIsolator = VitestKyselyTransactionIsolator;
 
-exports.VitestKyselyTransactionIsolator = require_VitestKyselyTransactionIsolator.VitestKyselyTransactionIsolator;
+//# sourceMappingURL=VitestKyselyTransactionIsolator.cjs.map

package/dist/VitestKyselyTransactionIsolator.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"VitestKyselyTransactionIsolator.cjs","names":["VitestPostgresTransactionIsolator"],"sources":["../src/VitestKyselyTransactionIsolator.ts"],"sourcesContent":["import type { Kysely, Transaction } from 'kysely';\nimport {\n\ttype IsolationLevel,\n\tVitestPostgresTransactionIsolator,\n} from './VitestTransactionIsolator';\n\n/**\n * Kysely-specific implementation of the Vitest transaction isolator.\n * Provides automatic transaction rollback for test isolation using Kysely's transaction API.\n * Each test runs within a database transaction that is rolled back after completion,\n * ensuring a clean state between tests without the overhead of recreating data.\n *\n * @template Database - The database schema type\n *\n * @example\n * ```typescript\n * import { VitestKyselyTransactionIsolator } from '@geekmidas/testkit';\n * import { db } from './database';\n *\n * // Create isolator instance\n * const isolator = new VitestKyselyTransactionIsolator<Database>();\n *\n * // In your test setup\n * beforeEach(async () => {\n *   await isolator.start(db);\n * });\n *\n * afterEach(async () => {\n *   await isolator.rollback();\n * });\n *\n * // Tests run in isolated transactions\n * it('should create user', async () => {\n *   const user = await db.insertInto('users')\n *     .values({ name: 'Test User' })\n *     .returningAll()\n *     .executeTakeFirst();\n *\n *   expect(user).toBeDefined();\n *   // This data will be rolled back after the test\n * });\n * ```\n */\nexport class VitestKyselyTransactionIsolator<\n\tDatabase,\n> extends VitestPostgresTransactionIsolator<\n\tKysely<Database>,\n\tTransaction<Database>\n> {\n\t/**\n\t * Closes the pool. Safe to implement now that it runs in the file's\n\t * teardown rather than after every test, where it would have closed the\n\t * connection the next test was about to use.\n\t */\n\tasync destroy(conn: Kysely<Database>): Promise<void> {\n\t\treturn conn.destroy();\n\t}\n\t/**\n\t * Creates a Kysely transaction with the specified isolation level.\n\t * Implements the abstract transact method from VitestPostgresTransactionIsolator.\n\t *\n\t * @param conn - The Kysely database connection\n\t * @param level - The transaction isolation level\n\t * @param fn - The function to execute within the transaction\n\t * @returns Promise that resolves when the transaction completes\n\t */\n\tasync transact(\n\t\tconn: Kysely<Database>,\n\t\tlevel: IsolationLevel,\n\t\tfn: (trx: Transaction<Database>) => Promise<void>,\n\t): Promise<void> {\n\t\tconst isolationLevel =\n\t\t\tlevel.toLocaleLowerCase() as Lowercase<IsolationLevel>;\n\t\tawait conn.transaction().setIsolationLevel(isolationLevel).execute(fn);\n\t}\n\t// Implement any Kysely-specific transaction logic here\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA2CA,IAAa,kCAAb,cAEUA,kCAAAA,kCAGR;;;;;;CAMD,MAAM,QAAQ,MAAuC;EACpD,OAAO,KAAK,QAAQ;CACrB;;;;;;;;;;CAUA,MAAM,SACL,MACA,OACA,IACgB;EAChB,MAAM,iBACL,MAAM,kBAAkB;EACzB,MAAM,KAAK,YAAY,CAAC,CAAC,kBAAkB,cAAc,CAAC,CAAC,QAAQ,EAAE;CACtE;AAED"}

package/dist/VitestKyselyTransactionIsolator.d.cts

@@ -1,3 +1,60 @@
-import "./VitestTransactionIsolator-glcxyS_R.cjs";
-import { VitestKyselyTransactionIsolator } from "./VitestKyselyTransactionIsolator-DJasVuIZ.cjs";
-export { VitestKyselyTransactionIsolator };
+import { IsolationLevel, VitestPostgresTransactionIsolator } from "./VitestTransactionIsolator.cjs";
+import { Kysely, Transaction } from "kysely";
+//#region src/VitestKyselyTransactionIsolator.d.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
+ * });
+ * ```
+ */
+export declare class VitestKyselyTransactionIsolator<Database> extends VitestPostgresTransactionIsolator<Kysely<Database>, Transaction<Database>> {
+  /**
+   * Closes the pool. Safe to implement now that it runs in the file's
+   * teardown rather than after every test, where it would have closed the
+   * connection the next test was about to use.
+   */
+  destroy(conn: Kysely<Database>): Promise<void>;
+  /**
+   * 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
+   */
+  transact(conn: Kysely<Database>, level: IsolationLevel, fn: (trx: Transaction<Database>) => Promise<void>): Promise<void>;
+}
+//#endregion
+//# sourceMappingURL=VitestKyselyTransactionIsolator.d.cts.map

package/dist/VitestKyselyTransactionIsolator.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"VitestKyselyTransactionIsolator.d.cts","names":[],"sources":["../src/VitestKyselyTransactionIsolator.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBA2Ca,gCACZ,kBACS,kCACT,OAAO,WACP,YAAY;;;;;;EAON,QAAQ,MAAM,OAAO,YAAY;;;;;;;;;;EAYjC,SACL,MAAM,OAAO,WACb,OAAO,gBACP,KAAK,KAAK,YAAY,cAAc,gBAClC"}

package/dist/VitestKyselyTransactionIsolator.d.mts

@@ -1,3 +1,60 @@
-import "./VitestTransactionIsolator-BLaw80cx.mjs";
-import { VitestKyselyTransactionIsolator } from "./VitestKyselyTransactionIsolator-CwlTo6yf.mjs";
-export { VitestKyselyTransactionIsolator };
+import { IsolationLevel, VitestPostgresTransactionIsolator } from "./VitestTransactionIsolator.mjs";
+import { Kysely, Transaction } from "kysely";
+//#region src/VitestKyselyTransactionIsolator.d.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
+ * });
+ * ```
+ */
+export declare class VitestKyselyTransactionIsolator<Database> extends VitestPostgresTransactionIsolator<Kysely<Database>, Transaction<Database>> {
+  /**
+   * Closes the pool. Safe to implement now that it runs in the file's
+   * teardown rather than after every test, where it would have closed the
+   * connection the next test was about to use.
+   */
+  destroy(conn: Kysely<Database>): Promise<void>;
+  /**
+   * 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
+   */
+  transact(conn: Kysely<Database>, level: IsolationLevel, fn: (trx: Transaction<Database>) => Promise<void>): Promise<void>;
+}
+//#endregion
+//# sourceMappingURL=VitestKyselyTransactionIsolator.d.mts.map

package/dist/VitestKyselyTransactionIsolator.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"VitestKyselyTransactionIsolator.d.mts","names":[],"sources":["../src/VitestKyselyTransactionIsolator.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBA2Ca,gCACZ,kBACS,kCACT,OAAO,WACP,YAAY;;;;;;EAON,QAAQ,MAAM,OAAO,YAAY;;;;;;;;;;EAYjC,SACL,MAAM,OAAO,WACb,OAAO,gBACP,KAAK,KAAK,YAAY,cAAc,gBAClC"}

package/dist/VitestKyselyTransactionIsolator.mjs

@@ -1,4 +1,66 @@
-import "./VitestTransactionIsolator-CvwPecpl.mjs";
-import { VitestKyselyTransactionIsolator } from "./VitestKyselyTransactionIsolator-1Saieke7.mjs";
+import { VitestPostgresTransactionIsolator } from "./VitestTransactionIsolator.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 {
+	/**
+	* Closes the pool. Safe to implement now that it runs in the file's
+	* teardown rather than after every test, where it would have closed the
+	* connection the next test was about to use.
+	*/
+	async destroy(conn) {
+		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, level, fn) {
+		const isolationLevel = level.toLocaleLowerCase();
+		await conn.transaction().setIsolationLevel(isolationLevel).execute(fn);
+	}
+};
+//#endregion
+export { VitestKyselyTransactionIsolator };
 
-export { VitestKyselyTransactionIsolator };
+//# sourceMappingURL=VitestKyselyTransactionIsolator.mjs.map

package/dist/VitestKyselyTransactionIsolator.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"VitestKyselyTransactionIsolator.mjs","names":[],"sources":["../src/VitestKyselyTransactionIsolator.ts"],"sourcesContent":["import type { Kysely, Transaction } from 'kysely';\nimport {\n\ttype IsolationLevel,\n\tVitestPostgresTransactionIsolator,\n} from './VitestTransactionIsolator';\n\n/**\n * Kysely-specific implementation of the Vitest transaction isolator.\n * Provides automatic transaction rollback for test isolation using Kysely's transaction API.\n * Each test runs within a database transaction that is rolled back after completion,\n * ensuring a clean state between tests without the overhead of recreating data.\n *\n * @template Database - The database schema type\n *\n * @example\n * ```typescript\n * import { VitestKyselyTransactionIsolator } from '@geekmidas/testkit';\n * import { db } from './database';\n *\n * // Create isolator instance\n * const isolator = new VitestKyselyTransactionIsolator<Database>();\n *\n * // In your test setup\n * beforeEach(async () => {\n *   await isolator.start(db);\n * });\n *\n * afterEach(async () => {\n *   await isolator.rollback();\n * });\n *\n * // Tests run in isolated transactions\n * it('should create user', async () => {\n *   const user = await db.insertInto('users')\n *     .values({ name: 'Test User' })\n *     .returningAll()\n *     .executeTakeFirst();\n *\n *   expect(user).toBeDefined();\n *   // This data will be rolled back after the test\n * });\n * ```\n */\nexport class VitestKyselyTransactionIsolator<\n\tDatabase,\n> extends VitestPostgresTransactionIsolator<\n\tKysely<Database>,\n\tTransaction<Database>\n> {\n\t/**\n\t * Closes the pool. Safe to implement now that it runs in the file's\n\t * teardown rather than after every test, where it would have closed the\n\t * connection the next test was about to use.\n\t */\n\tasync destroy(conn: Kysely<Database>): Promise<void> {\n\t\treturn conn.destroy();\n\t}\n\t/**\n\t * Creates a Kysely transaction with the specified isolation level.\n\t * Implements the abstract transact method from VitestPostgresTransactionIsolator.\n\t *\n\t * @param conn - The Kysely database connection\n\t * @param level - The transaction isolation level\n\t * @param fn - The function to execute within the transaction\n\t * @returns Promise that resolves when the transaction completes\n\t */\n\tasync transact(\n\t\tconn: Kysely<Database>,\n\t\tlevel: IsolationLevel,\n\t\tfn: (trx: Transaction<Database>) => Promise<void>,\n\t): Promise<void> {\n\t\tconst isolationLevel =\n\t\t\tlevel.toLocaleLowerCase() as Lowercase<IsolationLevel>;\n\t\tawait conn.transaction().setIsolationLevel(isolationLevel).execute(fn);\n\t}\n\t// Implement any Kysely-specific transaction logic here\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA2CA,IAAa,kCAAb,cAEU,kCAGR;;;;;;CAMD,MAAM,QAAQ,MAAuC;EACpD,OAAO,KAAK,QAAQ;CACrB;;;;;;;;;;CAUA,MAAM,SACL,MACA,OACA,IACgB;EAChB,MAAM,iBACL,MAAM,kBAAkB;EACzB,MAAM,KAAK,YAAY,CAAC,CAAC,kBAAkB,cAAc,CAAC,CAAC,QAAQ,EAAE;CACtE;AAED"}

package/dist/VitestObjectionTransactionIsolator.cjs

@@ -1,4 +1,63 @@
-require('./VitestTransactionIsolator-DyiX-QtK.cjs');
-const require_VitestObjectionTransactionIsolator = require('./VitestObjectionTransactionIsolator-DDoJTu7e.cjs');
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_VitestTransactionIsolator = require("./VitestTransactionIsolator.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 {
+	async destroy(_conn) {}
+	/**
+	* 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(connection, level, fn) {
+		const isolationLevel = level.toLowerCase();
+		await connection.transaction(async (trx) => {
+			await fn(trx);
+		}, { isolationLevel });
+	}
+};
+//#endregion
+exports.VitestObjectionTransactionIsolator = VitestObjectionTransactionIsolator;
 
-exports.VitestObjectionTransactionIsolator = require_VitestObjectionTransactionIsolator.VitestObjectionTransactionIsolator;
+//# sourceMappingURL=VitestObjectionTransactionIsolator.cjs.map

package/dist/VitestObjectionTransactionIsolator.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"VitestObjectionTransactionIsolator.cjs","names":["VitestPostgresTransactionIsolator"],"sources":["../src/VitestObjectionTransactionIsolator.ts"],"sourcesContent":["import type { Knex } from 'knex';\nimport {\n\ttype IsolationLevel,\n\tVitestPostgresTransactionIsolator,\n} from './VitestTransactionIsolator';\n\n/**\n * Objection.js-specific implementation of the Vitest transaction isolator.\n * Provides automatic transaction rollback for test isolation using Objection.js and Knex transaction API.\n * Each test runs within a database transaction that is rolled back after completion,\n * ensuring a clean state between tests without the overhead of recreating data.\n *\n * @example\n * ```typescript\n * import { VitestObjectionTransactionIsolator } from '@geekmidas/testkit';\n * import { knex } from './database';\n * import { User } from './models';\n * import { test } from 'vitest';\n *\n * // Create isolator instance\n * const isolator = new VitestObjectionTransactionIsolator(test);\n *\n * // Use with wrapped test API\n * const isolatedTest = isolator.wrapVitestWithTransaction(knex);\n *\n * isolatedTest('should create user', async ({ trx }) => {\n *   const user = await User.query(trx)\n *     .insert({ name: 'Test User' });\n *\n *   expect(user).toBeDefined();\n *   // This data will be rolled back after the test\n * });\n * ```\n */\nexport class VitestObjectionTransactionIsolator extends VitestPostgresTransactionIsolator<\n\tKnex,\n\tKnex.Transaction\n> {\n\tasync destroy(_conn: Knex<any, any[]>): Promise<void> {}\n\t/**\n\t * Creates a Knex transaction with the specified isolation level.\n\t * Implements the abstract transact method from VitestPostgresTransactionIsolator.\n\t * This transaction can be used with Objection.js models via Model.query(trx).\n\t *\n\t * @param conn - The Knex database connection\n\t * @param level - The transaction isolation level\n\t * @param fn - The function to execute within the transaction\n\t * @returns Promise that resolves when the transaction completes\n\t *\n\t * @example\n\t * ```typescript\n\t * await isolator.transact(knex, IsolationLevel.REPEATABLE_READ, async (trx) => {\n\t *   // Use transaction with Objection models\n\t *   await User.query(trx).insert({ name: 'Test' });\n\t *   await Post.query(trx).where('userId', user.id).delete();\n\t * });\n\t * ```\n\t */\n\tasync transact(\n\t\tconnection: Knex,\n\t\tlevel: IsolationLevel,\n\t\tfn: (trx: Knex.Transaction) => Promise<void>,\n\t): Promise<void> {\n\t\tconst isolationLevel = level.toLowerCase() as Lowercase<IsolationLevel>;\n\n\t\tawait connection.transaction(\n\t\t\tasync (trx) => {\n\t\t\t\tawait fn(trx);\n\t\t\t},\n\t\t\t{\n\t\t\t\tisolationLevel,\n\t\t\t},\n\t\t);\n\t}\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkCA,IAAa,qCAAb,cAAwDA,kCAAAA,kCAGtD;CACD,MAAM,QAAQ,OAAwC,CAAC;;;;;;;;;;;;;;;;;;;;CAoBvD,MAAM,SACL,YACA,OACA,IACgB;EAChB,MAAM,iBAAiB,MAAM,YAAY;EAEzC,MAAM,WAAW,YAChB,OAAO,QAAQ;GACd,MAAM,GAAG,GAAG;EACb,GACA,EACC,eACD,CACD;CACD;AACD"}

package/dist/VitestObjectionTransactionIsolator.d.cts

@@ -1,3 +1,56 @@
-import "./VitestTransactionIsolator-glcxyS_R.cjs";
-import { VitestObjectionTransactionIsolator } from "./VitestObjectionTransactionIsolator-CTTjvTPO.cjs";
-export { VitestObjectionTransactionIsolator };
+import { IsolationLevel, VitestPostgresTransactionIsolator } from "./VitestTransactionIsolator.cjs";
+import { Knex } from "knex";
+//#region src/VitestObjectionTransactionIsolator.d.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
+ * });
+ * ```
+ */
+export declare class VitestObjectionTransactionIsolator extends VitestPostgresTransactionIsolator<Knex, Knex.Transaction> {
+  destroy(_conn: Knex<any, any[]>): Promise<void>;
+  /**
+   * 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();
+   * });
+   * ```
+   */
+  transact(connection: Knex, level: IsolationLevel, fn: (trx: Knex.Transaction) => Promise<void>): Promise<void>;
+}
+//#endregion
+//# sourceMappingURL=VitestObjectionTransactionIsolator.d.cts.map

package/dist/VitestObjectionTransactionIsolator.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"VitestObjectionTransactionIsolator.d.cts","names":[],"sources":["../src/VitestObjectionTransactionIsolator.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAkCa,2CAA2C,kCACvD,MACA,KAAK;EAEC,QAAQ,OAAO,mBAAmB;;;;;;;;;;;;;;;;;;;;EAoBlC,SACL,YAAY,MACZ,OAAO,gBACP,KAAK,KAAK,KAAK,gBAAgB,gBAC7B"}

package/dist/VitestObjectionTransactionIsolator.d.mts

@@ -1,3 +1,56 @@
-import "./VitestTransactionIsolator-BLaw80cx.mjs";
-import { VitestObjectionTransactionIsolator } from "./VitestObjectionTransactionIsolator-CyZG6nq4.mjs";
-export { VitestObjectionTransactionIsolator };
+import { IsolationLevel, VitestPostgresTransactionIsolator } from "./VitestTransactionIsolator.mjs";
+import { Knex } from "knex";
+//#region src/VitestObjectionTransactionIsolator.d.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
+ * });
+ * ```
+ */
+export declare class VitestObjectionTransactionIsolator extends VitestPostgresTransactionIsolator<Knex, Knex.Transaction> {
+  destroy(_conn: Knex<any, any[]>): Promise<void>;
+  /**
+   * 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();
+   * });
+   * ```
+   */
+  transact(connection: Knex, level: IsolationLevel, fn: (trx: Knex.Transaction) => Promise<void>): Promise<void>;
+}
+//#endregion
+//# sourceMappingURL=VitestObjectionTransactionIsolator.d.mts.map

package/dist/VitestObjectionTransactionIsolator.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"VitestObjectionTransactionIsolator.d.mts","names":[],"sources":["../src/VitestObjectionTransactionIsolator.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAkCa,2CAA2C,kCACvD,MACA,KAAK;EAEC,QAAQ,OAAO,mBAAmB;;;;;;;;;;;;;;;;;;;;EAoBlC,SACL,YAAY,MACZ,OAAO,gBACP,KAAK,KAAK,KAAK,gBAAgB,gBAC7B"}

package/dist/VitestObjectionTransactionIsolator.mjs

@@ -1,4 +1,62 @@
-import "./VitestTransactionIsolator-CvwPecpl.mjs";
-import { VitestObjectionTransactionIsolator } from "./VitestObjectionTransactionIsolator-B_VSWFum.mjs";
+import { VitestPostgresTransactionIsolator } from "./VitestTransactionIsolator.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 {
+	async destroy(_conn) {}
+	/**
+	* 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(connection, level, fn) {
+		const isolationLevel = level.toLowerCase();
+		await connection.transaction(async (trx) => {
+			await fn(trx);
+		}, { isolationLevel });
+	}
+};
+//#endregion
+export { VitestObjectionTransactionIsolator };
 
-export { VitestObjectionTransactionIsolator };
+//# sourceMappingURL=VitestObjectionTransactionIsolator.mjs.map

package/dist/VitestObjectionTransactionIsolator.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"VitestObjectionTransactionIsolator.mjs","names":[],"sources":["../src/VitestObjectionTransactionIsolator.ts"],"sourcesContent":["import type { Knex } from 'knex';\nimport {\n\ttype IsolationLevel,\n\tVitestPostgresTransactionIsolator,\n} from './VitestTransactionIsolator';\n\n/**\n * Objection.js-specific implementation of the Vitest transaction isolator.\n * Provides automatic transaction rollback for test isolation using Objection.js and Knex transaction API.\n * Each test runs within a database transaction that is rolled back after completion,\n * ensuring a clean state between tests without the overhead of recreating data.\n *\n * @example\n * ```typescript\n * import { VitestObjectionTransactionIsolator } from '@geekmidas/testkit';\n * import { knex } from './database';\n * import { User } from './models';\n * import { test } from 'vitest';\n *\n * // Create isolator instance\n * const isolator = new VitestObjectionTransactionIsolator(test);\n *\n * // Use with wrapped test API\n * const isolatedTest = isolator.wrapVitestWithTransaction(knex);\n *\n * isolatedTest('should create user', async ({ trx }) => {\n *   const user = await User.query(trx)\n *     .insert({ name: 'Test User' });\n *\n *   expect(user).toBeDefined();\n *   // This data will be rolled back after the test\n * });\n * ```\n */\nexport class VitestObjectionTransactionIsolator extends VitestPostgresTransactionIsolator<\n\tKnex,\n\tKnex.Transaction\n> {\n\tasync destroy(_conn: Knex<any, any[]>): Promise<void> {}\n\t/**\n\t * Creates a Knex transaction with the specified isolation level.\n\t * Implements the abstract transact method from VitestPostgresTransactionIsolator.\n\t * This transaction can be used with Objection.js models via Model.query(trx).\n\t *\n\t * @param conn - The Knex database connection\n\t * @param level - The transaction isolation level\n\t * @param fn - The function to execute within the transaction\n\t * @returns Promise that resolves when the transaction completes\n\t *\n\t * @example\n\t * ```typescript\n\t * await isolator.transact(knex, IsolationLevel.REPEATABLE_READ, async (trx) => {\n\t *   // Use transaction with Objection models\n\t *   await User.query(trx).insert({ name: 'Test' });\n\t *   await Post.query(trx).where('userId', user.id).delete();\n\t * });\n\t * ```\n\t */\n\tasync transact(\n\t\tconnection: Knex,\n\t\tlevel: IsolationLevel,\n\t\tfn: (trx: Knex.Transaction) => Promise<void>,\n\t): Promise<void> {\n\t\tconst isolationLevel = level.toLowerCase() as Lowercase<IsolationLevel>;\n\n\t\tawait connection.transaction(\n\t\t\tasync (trx) => {\n\t\t\t\tawait fn(trx);\n\t\t\t},\n\t\t\t{\n\t\t\t\tisolationLevel,\n\t\t\t},\n\t\t);\n\t}\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkCA,IAAa,qCAAb,cAAwD,kCAGtD;CACD,MAAM,QAAQ,OAAwC,CAAC;;;;;;;;;;;;;;;;;;;;CAoBvD,MAAM,SACL,YACA,OACA,IACgB;EAChB,MAAM,iBAAiB,MAAM,YAAY;EAEzC,MAAM,WAAW,YAChB,OAAO,QAAQ;GACd,MAAM,GAAG,GAAG;EACb,GACA,EACC,eACD,CACD;CACD;AACD"}