@geekmidas/testkit 10.0.0-alpha.3 → 10.0.0-alpha.31

package/dist/VitestKyselyTransactionIsolator-CwlTo6yf.d.mts

@@ -1,64 +0,0 @@
-import { IsolationLevel, VitestPostgresTransactionIsolator } from "./VitestTransactionIsolator-BLaw80cx.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
- * });
- * ```
- */
-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>;
-}
-//# sourceMappingURL=VitestKyselyTransactionIsolator.d.ts.map
-//#endregion
-export { VitestKyselyTransactionIsolator };
-//# sourceMappingURL=VitestKyselyTransactionIsolator-CwlTo6yf.d.mts.map

package/dist/VitestKyselyTransactionIsolator-CwlTo6yf.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"VitestKyselyTransactionIsolator-CwlTo6yf.d.mts","names":[],"sources":["../src/VitestKyselyTransactionIsolator.ts"],"sourcesContent":[],"mappings":";;;;;;;AA2CA;;;;;;;;;;;;;;;;;AAE2C;;;;;;;;;;;;;;;;;;cAF9B,kDAEH,kCACT,OAAO,WACP,YAAY;;;;;;gBAOQ,OAAO,YAAY;;;;;;;;;;iBAahC,OAAO,kBACN,0BACG,YAAY,cAAc,gBAClC"}

package/dist/VitestKyselyTransactionIsolator-DJasVuIZ.d.cts

@@ -1,64 +0,0 @@
-import { IsolationLevel, VitestPostgresTransactionIsolator } from "./VitestTransactionIsolator-glcxyS_R.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
- * });
- * ```
- */
-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>;
-}
-//# sourceMappingURL=VitestKyselyTransactionIsolator.d.ts.map
-//#endregion
-export { VitestKyselyTransactionIsolator };
-//# sourceMappingURL=VitestKyselyTransactionIsolator-DJasVuIZ.d.cts.map

package/dist/VitestKyselyTransactionIsolator-DJasVuIZ.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"VitestKyselyTransactionIsolator-DJasVuIZ.d.cts","names":[],"sources":["../src/VitestKyselyTransactionIsolator.ts"],"sourcesContent":[],"mappings":";;;;;;;AA2CA;;;;;;;;;;;;;;;;;AAE2C;;;;;;;;;;;;;;;;;;cAF9B,kDAEH,kCACT,OAAO,WACP,YAAY;;;;;;gBAOQ,OAAO,YAAY;;;;;;;;;;iBAahC,OAAO,kBACN,0BACG,YAAY,cAAc,gBAClC"}

package/dist/VitestObjectionTransactionIsolator-B_VSWFum.mjs

@@ -1,63 +0,0 @@
-import { VitestPostgresTransactionIsolator } from "./VitestTransactionIsolator-CvwPecpl.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 };
-//# sourceMappingURL=VitestObjectionTransactionIsolator-B_VSWFum.mjs.map

package/dist/VitestObjectionTransactionIsolator-B_VSWFum.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"VitestObjectionTransactionIsolator-B_VSWFum.mjs","names":["_conn: Knex<any, any[]>","connection: Knex","level: IsolationLevel","fn: (trx: Knex.Transaction) => Promise<void>"],"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,QAAQA,OAAwC,CAAE;;;;;;;;;;;;;;;;;;;;CAoBxD,MAAM,SACLC,YACAC,OACAC,IACgB;EAChB,MAAM,iBAAiB,MAAM,aAAa;AAE1C,QAAM,WAAW,YAChB,OAAO,QAAQ;AACd,SAAM,GAAG,IAAI;EACb,GACD,EACC,eACA,EACD;CACD;AACD"}

package/dist/VitestObjectionTransactionIsolator-CTTjvTPO.d.cts

@@ -1,60 +0,0 @@
-import { IsolationLevel, VitestPostgresTransactionIsolator } from "./VitestTransactionIsolator-glcxyS_R.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
- * });
- * ```
- */
-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>;
-}
-//# sourceMappingURL=VitestObjectionTransactionIsolator.d.ts.map
-//#endregion
-export { VitestObjectionTransactionIsolator };
-//# sourceMappingURL=VitestObjectionTransactionIsolator-CTTjvTPO.d.cts.map

package/dist/VitestObjectionTransactionIsolator-CTTjvTPO.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"VitestObjectionTransactionIsolator-CTTjvTPO.d.cts","names":[],"sources":["../src/VitestObjectionTransactionIsolator.ts"],"sourcesContent":[],"mappings":";;;;;;;AAkCA;;;;;;;;;;;;AAAyF;;;;;;;;;;;;;;cAA5E,kCAAA,SAA2C,kCACvD,MACA,IAAA,CAAK;iBAEgB,mBAAmB;;;;;;;;;;;;;;;;;;;;uBAqB3B,aACL,0BACG,IAAA,CAAK,gBAAgB,gBAC7B"}

package/dist/VitestObjectionTransactionIsolator-CyZG6nq4.d.mts

@@ -1,60 +0,0 @@
-import { IsolationLevel, VitestPostgresTransactionIsolator } from "./VitestTransactionIsolator-BLaw80cx.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
- * });
- * ```
- */
-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>;
-}
-//# sourceMappingURL=VitestObjectionTransactionIsolator.d.ts.map
-//#endregion
-export { VitestObjectionTransactionIsolator };
-//# sourceMappingURL=VitestObjectionTransactionIsolator-CyZG6nq4.d.mts.map

package/dist/VitestObjectionTransactionIsolator-CyZG6nq4.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"VitestObjectionTransactionIsolator-CyZG6nq4.d.mts","names":[],"sources":["../src/VitestObjectionTransactionIsolator.ts"],"sourcesContent":[],"mappings":";;;;;;;AAkCA;;;;;;;;;;;;AAAyF;;;;;;;;;;;;;;cAA5E,kCAAA,SAA2C,kCACvD,MACA,IAAA,CAAK;iBAEgB,mBAAmB;;;;;;;;;;;;;;;;;;;;uBAqB3B,aACL,0BACG,IAAA,CAAK,gBAAgB,gBAC7B"}

package/dist/VitestObjectionTransactionIsolator-DDoJTu7e.cjs

@@ -1,68 +0,0 @@
-const require_VitestTransactionIsolator = require('./VitestTransactionIsolator-DyiX-QtK.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
-Object.defineProperty(exports, 'VitestObjectionTransactionIsolator', {
-  enumerable: true,
-  get: function () {
-    return VitestObjectionTransactionIsolator;
-  }
-});
-//# sourceMappingURL=VitestObjectionTransactionIsolator-DDoJTu7e.cjs.map

package/dist/VitestObjectionTransactionIsolator-DDoJTu7e.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"VitestObjectionTransactionIsolator-DDoJTu7e.cjs","names":["VitestPostgresTransactionIsolator","_conn: Knex<any, any[]>","connection: Knex","level: IsolationLevel","fn: (trx: Knex.Transaction) => Promise<void>"],"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,oEAGtD;CACD,MAAM,QAAQC,OAAwC,CAAE;;;;;;;;;;;;;;;;;;;;CAoBxD,MAAM,SACLC,YACAC,OACAC,IACgB;EAChB,MAAM,iBAAiB,MAAM,aAAa;AAE1C,QAAM,WAAW,YAChB,OAAO,QAAQ;AACd,SAAM,GAAG,IAAI;EACb,GACD,EACC,eACA,EACD;CACD;AACD"}

package/dist/VitestTransactionIsolator-BLaw80cx.d.mts

@@ -1,223 +0,0 @@
-import { Service } from "@geekmidas/services";
-import { TestAPI } from "vitest";
-
-//#region src/VitestTransactionIsolator.d.ts
-
-/**
- * Type definition for test fixtures that provide transaction access.
- * Used with Vitest's test.extend() API to inject transactions into tests.
- *
- * @template Transaction - The transaction type specific to the database driver
- * @template Extended - Additional context properties provided by the extend function
- */
-interface DatabaseFixtures<Transaction, _Extended = object> {
-  /**
-   * The database transaction available to the test.
-   * All database operations should use this transaction to ensure proper rollback.
-   */
-  trx: Transaction;
-}
-/**
- * Combined fixtures type that merges the base transaction fixture with extended context.
- */
-type ExtendedDatabaseFixtures<Transaction, Extended = object> = DatabaseFixtures<Transaction> & Extended;
-/**
- * Function type for extending test context with additional properties.
- * Receives the transaction and returns additional context to be merged with { trx }.
- *
- * @template Transaction - The transaction type
- * @template Extended - The type of additional context to provide
- *
- * @example
- * ```typescript
- * const extendContext: ExtendContextFn<Transaction<DB>, { factory: KyselyFactory }> =
- *   (trx) => ({ factory: new KyselyFactory(builders, seeds, trx) });
- * ```
- */
-type ExtendContextFn<Transaction, Extended> = (trx: Transaction) => Extended | Promise<Extended>;
-/**
- * PostgreSQL transaction isolation levels.
- * Controls the visibility of concurrent transactions.
- *
- * @see https://www.postgresql.org/docs/current/transaction-iso.html
- */
-declare enum IsolationLevel {
-  /**
-   * Lowest isolation level. Allows dirty reads.
-   * Not recommended for testing.
-   */
-  READ_UNCOMMITTED = "READ UNCOMMITTED",
-  /**
-   * Default PostgreSQL isolation level.
-   * Prevents dirty reads but allows non-repeatable reads.
-   */
-  READ_COMMITTED = "READ COMMITTED",
-  /**
-   * Prevents dirty reads and non-repeatable reads.
-   * Recommended for most test scenarios.
-   */
-  REPEATABLE_READ = "REPEATABLE READ",
-  /**
-   * Highest isolation level. Prevents all phenomena.
-   * May cause performance overhead in tests.
-   */
-  SERIALIZABLE = "SERIALIZABLE",
-}
-/**
- * Abstract base class for implementing database transaction isolation in Vitest tests.
- * Provides automatic transaction rollback after each test to maintain test isolation.
- * Subclasses must implement the transact() method for their specific database driver.
- *
- * @template TConn - The database connection type
- * @template Transaction - The transaction type
- *
- * @example
- * ```typescript
- * // Implement for your database driver
- * class MyDatabaseIsolator extends VitestPostgresTransactionIsolator<MyDB, MyTx> {
- *   async transact(conn: MyDB, level: IsolationLevel, fn: (tx: MyTx) => Promise<void>) {
- *     await conn.transaction(level, fn);
- *   }
- * }
- *
- * // Use in tests
- * const isolator = new MyDatabaseIsolator(test);
- * const isolatedTest = isolator.wrapVitestWithTransaction(db);
- *
- * isolatedTest('should create user', async ({ trx }) => {
- *   await trx.insert('users', { name: 'Test' });
- *   // Data is automatically rolled back after test
- * });
- * ```
- */
-declare abstract class VitestPostgresTransactionIsolator<TConn, Transaction> {
-  private readonly api;
-  /**
-   * Abstract method to create a transaction with the specified isolation level.
-   * Must be implemented by subclasses for specific database drivers.
-   *
-   * @param conn - The database connection
-   * @param isolationLevel - The transaction isolation level
-   * @param fn - The function to execute within the transaction
-   * @returns Promise that resolves when the transaction completes
-   */
-  abstract transact(conn: TConn, isolationLevel: IsolationLevel, fn: (trx: Transaction) => Promise<void>): Promise<void>;
-  abstract destroy(conn: TConn): Promise<void>;
-  /**
-   * Creates a new VitestPostgresTransactionIsolator instance.
-   *
-   * @param api - The Vitest test API (usually the `test` export from vitest)
-   */
-  constructor(api: TestAPI);
-  /**
-   * Creates a wrapped version of Vitest's test API that provides transaction isolation.
-   * Each test will run within a database transaction that is automatically rolled back.
-   *
-   * @param options - Configuration options for transaction wrapping
-   * @returns A wrapped test API with transaction support
-   *
-   * @example
-   * ```typescript
-   * const isolatedTest = isolator.wrapVitestWithTransaction({
-   *   connection: db,
-   *   setup: async (trx) => {
-   *     await trx.insert('settings', { key: 'test', value: 'true' });
-   *   },
-   *   fixtures: {
-   *     factory: (trx) => new Factory(trx),
-   *   },
-   * });
-   *
-   * isolatedTest('test with transaction', async ({ trx, factory }) => {
-   *   const user = await factory.insert('user', { name: 'Test' });
-   *   expect(user).toBeDefined();
-   * });
-   * ```
-   */
-  wrapVitestWithTransaction<Extended extends Record<string, unknown> = {}>(options: TransactionWrapperOptions<TConn, Transaction, Extended>): TestAPI<DatabaseFixtures<Transaction, object> & Extended>;
-}
-type DatabaseConnectionFn<Conn> = () => Conn | Promise<Conn>;
-/**
- * Where a connection comes from: a construct, or a function returning one.
- *
- * A construct is preferred, because it builds the client through the same
- * `connect()` production uses. A hand-rolled client missing `CamelCasePlugin`
- * writes `createdAt` where the app writes `created_at`, and the test passes
- * while production does not. The URL is read from `process.env`.
- */
-type DatabaseConnection<Conn> = DatabaseConnectionFn<Conn> | ConnectableConstruct<Conn>;
-/**
- * Options for wrapping Vitest tests with database transaction isolation.
- */
-/**
- * Anything that owns a service handing back a connection — a database
- * construct, structurally, so testkit depends on no construct package.
- */
-interface ConnectableConstruct<TConn> {
-  readonly service: Service<string, TConn>;
-}
-interface TransactionWrapperOptions<TConn, Transaction, Extended extends Record<string, unknown> = {}> {
-  /** Where the connection comes from — a construct, or a function returning one */
-  connection: DatabaseConnection<TConn>;
-  /** Optional setup function to run within the transaction before each test */
-  setup?: (trx: Transaction) => Promise<void>;
-  /** Transaction isolation level (defaults to REPEATABLE_READ) */
-  isolationLevel?: IsolationLevel;
-  /** Additional fixtures that depend on the transaction */
-  fixtures?: FixtureCreators<Transaction, Extended>;
-}
-/**
- * Type for fixture creator functions that depend on the transaction.
- * Each function receives the transaction and returns the fixture value.
- */
-type FixtureCreators<Transaction, Extended extends Record<string, unknown>> = { [K in keyof Extended]: (trx: Transaction) => Extended[K] | Promise<Extended[K]> };
-/**
- * The test API returned by extendWithFixtures.
- * Provides access to both the transaction (trx) and all extended fixtures.
- *
- * @template Transaction - The transaction type
- * @template Extended - The type of additional fixtures provided
- * @template BaseTest - The base wrapped test type
- */
-type TestWithExtendedFixtures<Transaction, Extended extends Record<string, unknown>, BaseTest extends ReturnType<TestAPI['extend']> = ReturnType<TestAPI['extend']>> = BaseTest & {
-  <C extends object>(name: string, fn: (context: DatabaseFixtures<Transaction> & Extended & C) => Promise<void>): void;
-  <C extends object>(name: string, options: object, fn: (context: DatabaseFixtures<Transaction> & Extended & C) => Promise<void>): void;
-};
-/**
- * Extends a wrapped test API with additional fixtures that depend on the transaction.
- * This allows composing test context with factories, repositories, or other helpers.
- *
- * @template Transaction - The transaction type
- * @template Extended - The type of additional context to provide
- * @param wrappedTest - The base wrapped test from wrapVitestWithTransaction
- * @param fixtures - Object mapping fixture names to creator functions
- * @returns An extended test API with both trx and the additional fixtures
- *
- * @example
- * ```typescript
- * import { wrapVitestKyselyTransaction, extendWithFixtures } from '@geekmidas/testkit/kysely';
- *
- * // Create base wrapped test
- * const baseTest = wrapVitestKyselyTransaction(test, {
- *   connection: db,
- *   setup: createTestTables,
- * });
- *
- * // Extend with fixtures
- * const it = extendWithFixtures(baseTest, {
- *   factory: (trx) => new KyselyFactory(builders, seeds, trx),
- *   userRepo: (trx) => new UserRepository(trx),
- * });
- *
- * // Use in tests - trx and all fixtures are available
- * it('should create user with factory', async ({ trx, factory, userRepo }) => {
- *   const user = await factory.insert('user', { name: 'Test' });
- *   expect(user).toBeDefined();
- * });
- * ```
- */
-declare function extendWithFixtures<Transaction, Extended extends Record<string, unknown>, T extends ReturnType<TestAPI['extend']> = any>(wrappedTest: T, fixtures: FixtureCreators<Transaction, Extended>): TestWithExtendedFixtures<Transaction, Extended, T>;
-//# sourceMappingURL=VitestTransactionIsolator.d.ts.map
-//#endregion
-export { ConnectableConstruct, DatabaseConnection, DatabaseConnectionFn, DatabaseFixtures, ExtendContextFn, ExtendedDatabaseFixtures, FixtureCreators, IsolationLevel, TestWithExtendedFixtures, TransactionWrapperOptions, VitestPostgresTransactionIsolator, extendWithFixtures };
-//# sourceMappingURL=VitestTransactionIsolator-BLaw80cx.d.mts.map

package/dist/VitestTransactionIsolator-BLaw80cx.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"VitestTransactionIsolator-BLaw80cx.d.mts","names":[],"sources":["../src/VitestTransactionIsolator.ts"],"sourcesContent":[],"mappings":";;;;;;;AAWA;AAWA;;;;AAGoC,UAdnB,gBAcmB,CAAA,WAAA,EAAA,YAAA,MAAA,CAAA,CAAA;EAAQ;AAe5C;;;EACiB,GACZ,EA1BC,WA0BD;;;AAAkB;AAQvB;AAkDsB,KA9EV,wBA8EU,CAAA,WAAiC,EAAA,WAAA,MAAA,CAAA,GA3EnD,gBA2EmD,CA3ElC,WA2EkC,CAAA,GA3EnB,QA2EmB;;;;;;;;;;;;;;AAkD5C,KA9GC,eA8GD,CAAA,WAAA,EAAA,QAAA,CAAA,GAAA,CAAA,GAAA,EA7GL,WA6GK,EAAA,GA5GN,QA4GM,GA5GK,OA4GL,CA5Ga,QA4Gb,CAAA;;;;;AAAuD;AA8FlE;AAAgC,aAlMpB,cAAA;EAkMoB;;;AAA6B;EAUjD,gBAAA,GAAA,kBAAkB;EAAA;;;;EAEF,cAAzB,GAAA,gBAAA;EAAoB;AAgBvB;;;EACwC,eAArB,GAAA,iBAAA;EAAO;AAG1B;;;EAGwB,YAGQ,GAAA,cAAA;;;;;;;;AAML;AAO3B;;;;;;;;;;AAM2B;AAW3B;;;;;;;;;AAUY,uBA9NU,iCA8NV,CAAA,KAAA,EAAA,WAAA,CAAA,CAAA;EAAgB,iBAAgB,GAAA;EAAQ;;;;;;;AAQtC;AAqCd;EAAkC,SAAA,QAAA,CAAA,IAAA,EAhQ1B,KAgQ0B,EAAA,cAAA,EA/PhB,cA+PgB,EAAA,EAAA,EAAA,CAAA,GAAA,EA9PtB,WA8PsB,EAAA,GA9PN,OA8PM,CAAA,IAAA,CAAA,CAAA,EA7P9B,OA6P8B,CAAA,IAAA,CAAA;EAAA,SAEhB,OAAA,CAAA,IAAA,EA7PM,KA6PN,CAAA,EA7Pc,OA6Pd,CAAA,IAAA,CAAA;EAAM;;;;;EAKwB,WAArC,CAAA,GAAA,EA5PwB,OA4PxB;EAAe;;;;AACC;;;;;;;;;;;;;;;;;;;;;6CAlOiB,uCACjC,0BAA0B,OAAO,aAAa,YAAS,QAAA,iBAAA,uBAAA;;KA8FtD,mCAAmC,OAAO,QAAQ;;;;;;;;;KAUlD,2BACT,qBAAqB,QACrB,qBAAqB;;;;;;;;UAgBP;oBACE,gBAAgB;;UAGlB,+DAGC;;cAGL,mBAAmB;;gBAEjB,gBAAgB;;mBAEb;;aAEN,gBAAgB,aAAa;;;;;;KAO7B,8CAEM,yCAEL,iBACN,gBACD,SAAS,KAAK,QAAQ,SAAS;;;;;;;;;KAWzB,uDAEM,0CACA,WAAW,qBAAqB,WAChD,sBAEE;iDAIQ,iBAAiB,eAAe,WAAW,MAChD;kEAMK,iBAAiB,eAAe,WAAW,MAChD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAqCS,iDAEE,mCAEP,WAAW,uCAER,aACH,gBAAgB,aAAa,YACrC,yBAAyB,aAAa,UAAU"}