@geekmidas/testkit 0.1.1 → 0.3.0

package/dist/{VitestTransactionIsolator-BKIrj3Uy.cjs → VitestTransactionIsolator-CMfJXZP8.cjs}

@@ -69,51 +69,64 @@ var VitestPostgresTransactionIsolator = class {
 	* 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 conn - The database connection to use
-	* @param setup - Optional setup function to run within the transaction before each test
-	* @param level - The transaction isolation level (defaults to REPEATABLE_READ)
+	* @param options - Configuration options for transaction wrapping
 	* @returns A wrapped test API with transaction support
 	*
 	* @example
 	* ```typescript
-	* const isolatedTest = isolator.wrapVitestWithTransaction(db, async (trx) => {
-	*   // Optional setup: create common test data
-	*   await trx.insert('settings', { key: 'test', value: 'true' });
+	* 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 }) => {
-	*   const user = await trx.insert('users', { name: 'Test' });
+	* isolatedTest('test with transaction', async ({ trx, factory }) => {
+	*   const user = await factory.insert('user', { name: 'Test' });
 	*   expect(user).toBeDefined();
 	* });
 	* ```
 	*/
-	wrapVitestWithTransaction(createConnection, setup, level = IsolationLevel.REPEATABLE_READ) {
-		return this.api.extend({ trx: async ({}, use) => {
-			class TestRollback extends Error {
-				constructor() {
-					super("Test rollback");
-					this.name = "TestRollback";
-				}
-			}
-			let testError;
-			const conn = await createConnection();
-			try {
-				await this.transact(conn, level, async (transaction) => {
-					try {
-						await setup?.(transaction);
-						await use(transaction);
-					} catch (error) {
-						testError = error;
+	wrapVitestWithTransaction(options) {
+		const { connection, setup, isolationLevel = IsolationLevel.REPEATABLE_READ, fixtures } = options;
+		const additionalFixtures = {};
+		if (fixtures) for (const [key, creator] of Object.entries(fixtures)) additionalFixtures[key] = async ({ trx }, use) => {
+			const value = await creator(trx);
+			await use(value);
+		};
+		const extendFn = this.api.extend;
+		return extendFn({
+			trx: async ({}, use) => {
+				class TestRollback extends Error {
+					constructor() {
+						super("Test rollback");
+						this.name = "TestRollback";
 					}
-					throw new TestRollback();
-				});
-			} catch (error) {
-				if (!(error instanceof TestRollback)) throw error;
-				if (testError) throw testError;
-			} finally {
-				await this.destroy(conn);
-			}
-		} });
+				}
+				let testError;
+				const conn = await connection();
+				try {
+					await this.transact(conn, isolationLevel, async (transaction) => {
+						try {
+							await setup?.(transaction);
+							await use(transaction);
+						} catch (error) {
+							testError = error;
+						}
+						throw new TestRollback();
+					});
+				} catch (error) {
+					if (!(error instanceof TestRollback)) throw error;
+					if (testError) throw testError;
+				} finally {
+					await this.destroy(conn);
+				}
+			},
+			...additionalFixtures
+		});
 	}
 };
 /**
@@ -131,7 +144,10 @@ var VitestPostgresTransactionIsolator = class {
 * import { wrapVitestKyselyTransaction, extendWithFixtures } from '@geekmidas/testkit/kysely';
 *
 * // Create base wrapped test
-* const baseTest = wrapVitestKyselyTransaction(test, db, createTestTables);
+* const baseTest = wrapVitestKyselyTransaction(test, {
+*   connection: db,
+*   setup: createTestTables,
+* });
 *
 * // Extend with fixtures
 * const it = extendWithFixtures(baseTest, {
@@ -174,4 +190,4 @@ Object.defineProperty(exports, 'extendWithFixtures', {
     return extendWithFixtures;
   }
 });
-//# sourceMappingURL=VitestTransactionIsolator-BKIrj3Uy.cjs.map
+//# sourceMappingURL=VitestTransactionIsolator-CMfJXZP8.cjs.map

package/dist/VitestTransactionIsolator-CMfJXZP8.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"VitestTransactionIsolator-CMfJXZP8.cjs","names":["api: TestAPI","options: TransactionWrapperOptions<TConn, Transaction, Extended>","additionalFixtures: Record<string, unknown>","use: (value: unknown) => Promise<void>","use: (value: Transaction) => Promise<void>","testError: Error | undefined","wrappedTest: T","fixtures: FixtureCreators<Transaction, Extended>","fixtureDefinitions: Record<string, any>"],"sources":["../src/VitestTransactionIsolator.ts"],"sourcesContent":["import type { TestAPI } from 'vitest';\n\n/**\n * Type definition for test fixtures that provide transaction access.\n * Used with Vitest's test.extend() API to inject transactions into tests.\n *\n * @template Transaction - The transaction type specific to the database driver\n * @template Extended - Additional context properties provided by the extend function\n */\nexport interface DatabaseFixtures<Transaction, Extended = object> {\n  /**\n   * The database transaction available to the test.\n   * All database operations should use this transaction to ensure proper rollback.\n   */\n  trx: Transaction;\n}\n\n/**\n * Combined fixtures type that merges the base transaction fixture with extended context.\n */\nexport type ExtendedDatabaseFixtures<\n  Transaction,\n  Extended = object,\n> = DatabaseFixtures<Transaction> & Extended;\n\n/**\n * Function type for extending test context with additional properties.\n * Receives the transaction and returns additional context to be merged with { trx }.\n *\n * @template Transaction - The transaction type\n * @template Extended - The type of additional context to provide\n *\n * @example\n * ```typescript\n * const extendContext: ExtendContextFn<Transaction<DB>, { factory: KyselyFactory }> =\n *   (trx) => ({ factory: new KyselyFactory(builders, seeds, trx) });\n * ```\n */\nexport type ExtendContextFn<Transaction, Extended> = (\n  trx: Transaction,\n) => Extended | Promise<Extended>;\n\n/**\n * PostgreSQL transaction isolation levels.\n * Controls the visibility of concurrent transactions.\n *\n * @see https://www.postgresql.org/docs/current/transaction-iso.html\n */\nexport enum IsolationLevel {\n  /**\n   * Lowest isolation level. Allows dirty reads.\n   * Not recommended for testing.\n   */\n  READ_UNCOMMITTED = 'READ UNCOMMITTED',\n  /**\n   * Default PostgreSQL isolation level.\n   * Prevents dirty reads but allows non-repeatable reads.\n   */\n  READ_COMMITTED = 'READ COMMITTED',\n  /**\n   * Prevents dirty reads and non-repeatable reads.\n   * Recommended for most test scenarios.\n   */\n  REPEATABLE_READ = 'REPEATABLE READ',\n  /**\n   * Highest isolation level. Prevents all phenomena.\n   * May cause performance overhead in tests.\n   */\n  SERIALIZABLE = 'SERIALIZABLE',\n}\n\n/**\n * Abstract base class for implementing database transaction isolation in Vitest tests.\n * Provides automatic transaction rollback after each test to maintain test isolation.\n * Subclasses must implement the transact() method for their specific database driver.\n *\n * @template TConn - The database connection type\n * @template Transaction - The transaction type\n *\n * @example\n * ```typescript\n * // Implement for your database driver\n * class MyDatabaseIsolator extends VitestPostgresTransactionIsolator<MyDB, MyTx> {\n *   async transact(conn: MyDB, level: IsolationLevel, fn: (tx: MyTx) => Promise<void>) {\n *     await conn.transaction(level, fn);\n *   }\n * }\n *\n * // Use in tests\n * const isolator = new MyDatabaseIsolator(test);\n * const isolatedTest = isolator.wrapVitestWithTransaction(db);\n *\n * isolatedTest('should create user', async ({ trx }) => {\n *   await trx.insert('users', { name: 'Test' });\n *   // Data is automatically rolled back after test\n * });\n * ```\n */\nexport abstract class VitestPostgresTransactionIsolator<TConn, Transaction> {\n  /**\n   * Abstract method to create a transaction with the specified isolation level.\n   * Must be implemented by subclasses for specific database drivers.\n   *\n   * @param conn - The database connection\n   * @param isolationLevel - The transaction isolation level\n   * @param fn - The function to execute within the transaction\n   * @returns Promise that resolves when the transaction completes\n   */\n  abstract transact(\n    conn: TConn,\n    isolationLevel: IsolationLevel,\n    fn: (trx: Transaction) => Promise<void>,\n  ): Promise<void>;\n\n  abstract destroy(conn: TConn): Promise<void>;\n  /**\n   * Creates a new VitestPostgresTransactionIsolator instance.\n   *\n   * @param api - The Vitest test API (usually the `test` export from vitest)\n   */\n  constructor(private readonly api: TestAPI) {}\n\n  /**\n   * Creates a wrapped version of Vitest's test API that provides transaction isolation.\n   * Each test will run within a database transaction that is automatically rolled back.\n   *\n   * @param options - Configuration options for transaction wrapping\n   * @returns A wrapped test API with transaction support\n   *\n   * @example\n   * ```typescript\n   * const isolatedTest = isolator.wrapVitestWithTransaction({\n   *   connection: db,\n   *   setup: async (trx) => {\n   *     await trx.insert('settings', { key: 'test', value: 'true' });\n   *   },\n   *   fixtures: {\n   *     factory: (trx) => new Factory(trx),\n   *   },\n   * });\n   *\n   * isolatedTest('test with transaction', async ({ trx, factory }) => {\n   *   const user = await factory.insert('user', { name: 'Test' });\n   *   expect(user).toBeDefined();\n   * });\n   * ```\n   */\n  wrapVitestWithTransaction<Extended extends Record<string, unknown> = {}>(\n    options: TransactionWrapperOptions<TConn, Transaction, Extended>,\n  ) {\n    const {\n      connection,\n      setup,\n      isolationLevel = IsolationLevel.REPEATABLE_READ,\n      fixtures,\n    } = options;\n\n    // Build fixture definitions for additional fixtures that depend on trx\n    const additionalFixtures: Record<string, unknown> = {};\n    if (fixtures) {\n      for (const [key, creator] of Object.entries(fixtures)) {\n        additionalFixtures[key] = async (\n          { trx }: { trx: Transaction },\n          use: (value: unknown) => Promise<void>,\n        ) => {\n          const value = await (creator as (trx: Transaction) => unknown)(trx);\n          await use(value);\n        };\n      }\n    }\n\n    type CombinedFixtures = DatabaseFixtures<Transaction> & Extended;\n\n    // Cast to bypass Vitest's strict fixture typing which can't infer\n    // dynamically built fixture objects\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    const extendFn = this.api.extend as <T>(fixtures: any) => TestAPI<T>;\n\n    return extendFn<CombinedFixtures>({\n      // This fixture automatically provides a transaction to each test\n      trx: async ({}, use: (value: Transaction) => Promise<void>) => {\n        // Create a custom error class for rollback\n        class TestRollback extends Error {\n          constructor() {\n            super('Test rollback');\n            this.name = 'TestRollback';\n          }\n        }\n\n        let testError: Error | undefined;\n        const conn = await connection();\n        try {\n          await this.transact(conn, isolationLevel, async (transaction) => {\n            try {\n              // Provide the transaction to the test\n              await setup?.(transaction);\n              await use(transaction);\n            } catch (error) {\n              // Capture any test errors\n              testError = error as Error;\n            }\n\n            // Always throw to trigger rollback\n            throw new TestRollback();\n          });\n        } catch (error) {\n          // Only rethrow if it's not our rollback error\n          if (!(error instanceof TestRollback)) {\n            throw error;\n          }\n\n          // If the test had an error, throw it now\n          if (testError) {\n            throw testError;\n          }\n        } finally {\n          await this.destroy(conn);\n        }\n      },\n      ...additionalFixtures,\n    });\n  }\n}\n\nexport type DatabaseConnectionFn<Conn> = () => Conn | Promise<Conn>;\nexport type DatabaseConnection<Conn> = DatabaseConnectionFn<Conn>;\n\n/**\n * Options for wrapping Vitest tests with database transaction isolation.\n */\nexport interface TransactionWrapperOptions<\n  TConn,\n  Transaction,\n  Extended extends Record<string, unknown> = {},\n> {\n  /** Function that creates or returns a database connection */\n  connection: DatabaseConnection<TConn>;\n  /** Optional setup function to run within the transaction before each test */\n  setup?: (trx: Transaction) => Promise<void>;\n  /** Transaction isolation level (defaults to REPEATABLE_READ) */\n  isolationLevel?: IsolationLevel;\n  /** Additional fixtures that depend on the transaction */\n  fixtures?: FixtureCreators<Transaction, Extended>;\n}\n\n/**\n * Type for fixture creator functions that depend on the transaction.\n * Each function receives the transaction and returns the fixture value.\n */\nexport type FixtureCreators<\n  Transaction,\n  Extended extends Record<string, unknown>,\n> = {\n  [K in keyof Extended]: (\n    trx: Transaction,\n  ) => Extended[K] | Promise<Extended[K]>;\n};\n\n/**\n * The test API returned by extendWithFixtures.\n * Provides access to both the transaction (trx) and all extended fixtures.\n *\n * @template Transaction - The transaction type\n * @template Extended - The type of additional fixtures provided\n * @template BaseTest - The base wrapped test type\n */\nexport type TestWithExtendedFixtures<\n  Transaction,\n  Extended extends Record<string, unknown>,\n  BaseTest extends ReturnType<TestAPI['extend']> = ReturnType<\n    TestAPI['extend']\n  >,\n> = BaseTest & {\n  <C extends object>(\n    name: string,\n    fn: (\n      context: DatabaseFixtures<Transaction> & Extended & C,\n    ) => Promise<void>,\n  ): void;\n  <C extends object>(\n    name: string,\n    options: object,\n    fn: (\n      context: DatabaseFixtures<Transaction> & Extended & C,\n    ) => Promise<void>,\n  ): void;\n};\n\n/**\n * Extends a wrapped test API with additional fixtures that depend on the transaction.\n * This allows composing test context with factories, repositories, or other helpers.\n *\n * @template Transaction - The transaction type\n * @template Extended - The type of additional context to provide\n * @param wrappedTest - The base wrapped test from wrapVitestWithTransaction\n * @param fixtures - Object mapping fixture names to creator functions\n * @returns An extended test API with both trx and the additional fixtures\n *\n * @example\n * ```typescript\n * import { wrapVitestKyselyTransaction, extendWithFixtures } from '@geekmidas/testkit/kysely';\n *\n * // Create base wrapped test\n * const baseTest = wrapVitestKyselyTransaction(test, {\n *   connection: db,\n *   setup: createTestTables,\n * });\n *\n * // Extend with fixtures\n * const it = extendWithFixtures(baseTest, {\n *   factory: (trx) => new KyselyFactory(builders, seeds, trx),\n *   userRepo: (trx) => new UserRepository(trx),\n * });\n *\n * // Use in tests - trx and all fixtures are available\n * it('should create user with factory', async ({ trx, factory, userRepo }) => {\n *   const user = await factory.insert('user', { name: 'Test' });\n *   expect(user).toBeDefined();\n * });\n * ```\n */\nexport function extendWithFixtures<\n  Transaction,\n  Extended extends Record<string, unknown>,\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  T extends ReturnType<TestAPI['extend']> = any,\n>(\n  wrappedTest: T,\n  fixtures: FixtureCreators<Transaction, Extended>,\n): TestWithExtendedFixtures<Transaction, Extended, T> {\n  // Build fixture definitions for Vitest's extend API\n  const fixtureDefinitions: Record<string, any> = {};\n\n  for (const [key, creator] of Object.entries(fixtures)) {\n    fixtureDefinitions[key] = async (\n      { trx }: { trx: Transaction },\n      use: (value: unknown) => Promise<void>,\n    ) => {\n      const value = await (creator as (trx: Transaction) => unknown)(trx);\n      await use(value);\n    };\n  }\n\n  return (wrappedTest as any).extend(fixtureDefinitions);\n}\n"],"mappings":";;;;;;;;AAgDA,IAAY,4DAAL;;;;;AAKL;;;;;AAKA;;;;;AAKA;;;;;AAKA;;AACD;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6BD,IAAsB,oCAAtB,MAA4E;;;;;;CAsB1E,YAA6BA,KAAc;EAAd;CAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;CA2B7C,0BACEC,SACA;EACA,MAAM,EACJ,YACA,OACA,iBAAiB,eAAe,iBAChC,UACD,GAAG;EAGJ,MAAMC,qBAA8C,CAAE;AACtD,MAAI,SACF,MAAK,MAAM,CAAC,KAAK,QAAQ,IAAI,OAAO,QAAQ,SAAS,CACnD,oBAAmB,OAAO,OACxB,EAAE,KAA2B,EAC7BC,QACG;GACH,MAAM,QAAQ,MAAM,AAAC,QAA0C,IAAI;AACnE,SAAM,IAAI,MAAM;EACjB;EASL,MAAM,WAAW,KAAK,IAAI;AAE1B,SAAO,SAA2B;GAEhC,KAAK,OAAO,EAAE,EAAEC,QAA+C;IAE7D,MAAM,qBAAqB,MAAM;KAC/B,cAAc;AACZ,YAAM,gBAAgB;AACtB,WAAK,OAAO;KACb;IACF;IAED,IAAIC;IACJ,MAAM,OAAO,MAAM,YAAY;AAC/B,QAAI;AACF,WAAM,KAAK,SAAS,MAAM,gBAAgB,OAAO,gBAAgB;AAC/D,UAAI;AAEF,aAAM,QAAQ,YAAY;AAC1B,aAAM,IAAI,YAAY;MACvB,SAAQ,OAAO;AAEd,mBAAY;MACb;AAGD,YAAM,IAAI;KACX,EAAC;IACH,SAAQ,OAAO;AAEd,WAAM,iBAAiB,cACrB,OAAM;AAIR,SAAI,UACF,OAAM;IAET,UAAS;AACR,WAAM,KAAK,QAAQ,KAAK;IACzB;GACF;GACD,GAAG;EACJ,EAAC;CACH;AACF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAmGD,SAAgB,mBAMdC,aACAC,UACoD;CAEpD,MAAMC,qBAA0C,CAAE;AAElD,MAAK,MAAM,CAAC,KAAK,QAAQ,IAAI,OAAO,QAAQ,SAAS,CACnD,oBAAmB,OAAO,OACxB,EAAE,KAA2B,EAC7BL,QACG;EACH,MAAM,QAAQ,MAAM,AAAC,QAA0C,IAAI;AACnE,QAAM,IAAI,MAAM;CACjB;AAGH,QAAO,AAAC,YAAoB,OAAO,mBAAmB;AACvD"}

package/dist/{VitestTransactionIsolator-DfA80g2M.d.cts → VitestTransactionIsolator-CwQaxZLP.d.cts}

@@ -112,30 +112,44 @@ declare abstract class VitestPostgresTransactionIsolator<TConn, Transaction> {
    * 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 conn - The database connection to use
-   * @param setup - Optional setup function to run within the transaction before each test
-   * @param level - The transaction isolation level (defaults to REPEATABLE_READ)
+   * @param options - Configuration options for transaction wrapping
    * @returns A wrapped test API with transaction support
    *
    * @example
    * ```typescript
-   * const isolatedTest = isolator.wrapVitestWithTransaction(db, async (trx) => {
-   *   // Optional setup: create common test data
-   *   await trx.insert('settings', { key: 'test', value: 'true' });
+   * 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 }) => {
-   *   const user = await trx.insert('users', { name: 'Test' });
+   * isolatedTest('test with transaction', async ({ trx, factory }) => {
+   *   const user = await factory.insert('user', { name: 'Test' });
    *   expect(user).toBeDefined();
    * });
    * ```
    */
-  wrapVitestWithTransaction(createConnection: DatabaseConnection<TConn>, setup?: (trx: Transaction) => Promise<void>, level?: IsolationLevel): TestAPI<{
-    trx: Transaction;
-  }>;
+  wrapVitestWithTransaction<Extended extends Record<string, unknown> = {}>(options: TransactionWrapperOptions<TConn, Transaction, Extended>): TestAPI<DatabaseFixtures<Transaction, object> & Extended>;
 }
 type DatabaseConnectionFn<Conn> = () => Conn | Promise<Conn>;
 type DatabaseConnection<Conn> = DatabaseConnectionFn<Conn>;
+/**
+ * Options for wrapping Vitest tests with database transaction isolation.
+ */
+interface TransactionWrapperOptions<TConn, Transaction, Extended extends Record<string, unknown> = {}> {
+  /** Function that creates or returns a database connection */
+  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.
@@ -168,7 +182,10 @@ type TestWithExtendedFixtures<Transaction, Extended extends Record<string, unkno
  * import { wrapVitestKyselyTransaction, extendWithFixtures } from '@geekmidas/testkit/kysely';
  *
  * // Create base wrapped test
- * const baseTest = wrapVitestKyselyTransaction(test, db, createTestTables);
+ * const baseTest = wrapVitestKyselyTransaction(test, {
+ *   connection: db,
+ *   setup: createTestTables,
+ * });
  *
  * // Extend with fixtures
  * const it = extendWithFixtures(baseTest, {
@@ -185,5 +202,5 @@ type TestWithExtendedFixtures<Transaction, Extended extends Record<string, unkno
  */
 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>;
 //#endregion
-export { DatabaseConnection, DatabaseConnectionFn, DatabaseFixtures, ExtendContextFn, ExtendedDatabaseFixtures, FixtureCreators, IsolationLevel, TestWithExtendedFixtures, VitestPostgresTransactionIsolator, extendWithFixtures };
-//# sourceMappingURL=VitestTransactionIsolator-DfA80g2M.d.cts.map
+export { DatabaseConnection, DatabaseConnectionFn, DatabaseFixtures, ExtendContextFn, ExtendedDatabaseFixtures, FixtureCreators, IsolationLevel, TestWithExtendedFixtures, TransactionWrapperOptions, VitestPostgresTransactionIsolator, extendWithFixtures };
+//# sourceMappingURL=VitestTransactionIsolator-CwQaxZLP.d.cts.map

package/dist/{VitestTransactionIsolator-BIaMs4c2.mjs → VitestTransactionIsolator-DQ7tLqgV.mjs}

@@ -68,51 +68,64 @@ var VitestPostgresTransactionIsolator = class {
 	* 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 conn - The database connection to use
-	* @param setup - Optional setup function to run within the transaction before each test
-	* @param level - The transaction isolation level (defaults to REPEATABLE_READ)
+	* @param options - Configuration options for transaction wrapping
 	* @returns A wrapped test API with transaction support
 	*
 	* @example
 	* ```typescript
-	* const isolatedTest = isolator.wrapVitestWithTransaction(db, async (trx) => {
-	*   // Optional setup: create common test data
-	*   await trx.insert('settings', { key: 'test', value: 'true' });
+	* 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 }) => {
-	*   const user = await trx.insert('users', { name: 'Test' });
+	* isolatedTest('test with transaction', async ({ trx, factory }) => {
+	*   const user = await factory.insert('user', { name: 'Test' });
 	*   expect(user).toBeDefined();
 	* });
 	* ```
 	*/
-	wrapVitestWithTransaction(createConnection, setup, level = IsolationLevel.REPEATABLE_READ) {
-		return this.api.extend({ trx: async ({}, use) => {
-			class TestRollback extends Error {
-				constructor() {
-					super("Test rollback");
-					this.name = "TestRollback";
-				}
-			}
-			let testError;
-			const conn = await createConnection();
-			try {
-				await this.transact(conn, level, async (transaction) => {
-					try {
-						await setup?.(transaction);
-						await use(transaction);
-					} catch (error) {
-						testError = error;
+	wrapVitestWithTransaction(options) {
+		const { connection, setup, isolationLevel = IsolationLevel.REPEATABLE_READ, fixtures } = options;
+		const additionalFixtures = {};
+		if (fixtures) for (const [key, creator] of Object.entries(fixtures)) additionalFixtures[key] = async ({ trx }, use) => {
+			const value = await creator(trx);
+			await use(value);
+		};
+		const extendFn = this.api.extend;
+		return extendFn({
+			trx: async ({}, use) => {
+				class TestRollback extends Error {
+					constructor() {
+						super("Test rollback");
+						this.name = "TestRollback";
 					}
-					throw new TestRollback();
-				});
-			} catch (error) {
-				if (!(error instanceof TestRollback)) throw error;
-				if (testError) throw testError;
-			} finally {
-				await this.destroy(conn);
-			}
-		} });
+				}
+				let testError;
+				const conn = await connection();
+				try {
+					await this.transact(conn, isolationLevel, async (transaction) => {
+						try {
+							await setup?.(transaction);
+							await use(transaction);
+						} catch (error) {
+							testError = error;
+						}
+						throw new TestRollback();
+					});
+				} catch (error) {
+					if (!(error instanceof TestRollback)) throw error;
+					if (testError) throw testError;
+				} finally {
+					await this.destroy(conn);
+				}
+			},
+			...additionalFixtures
+		});
 	}
 };
 /**
@@ -130,7 +143,10 @@ var VitestPostgresTransactionIsolator = class {
 * import { wrapVitestKyselyTransaction, extendWithFixtures } from '@geekmidas/testkit/kysely';
 *
 * // Create base wrapped test
-* const baseTest = wrapVitestKyselyTransaction(test, db, createTestTables);
+* const baseTest = wrapVitestKyselyTransaction(test, {
+*   connection: db,
+*   setup: createTestTables,
+* });
 *
 * // Extend with fixtures
 * const it = extendWithFixtures(baseTest, {
@@ -156,4 +172,4 @@ function extendWithFixtures(wrappedTest, fixtures) {
 
 //#endregion
 export { IsolationLevel, VitestPostgresTransactionIsolator, extendWithFixtures };
-//# sourceMappingURL=VitestTransactionIsolator-BIaMs4c2.mjs.map
+//# sourceMappingURL=VitestTransactionIsolator-DQ7tLqgV.mjs.map

package/dist/VitestTransactionIsolator-DQ7tLqgV.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"VitestTransactionIsolator-DQ7tLqgV.mjs","names":["api: TestAPI","options: TransactionWrapperOptions<TConn, Transaction, Extended>","additionalFixtures: Record<string, unknown>","use: (value: unknown) => Promise<void>","use: (value: Transaction) => Promise<void>","testError: Error | undefined","wrappedTest: T","fixtures: FixtureCreators<Transaction, Extended>","fixtureDefinitions: Record<string, any>"],"sources":["../src/VitestTransactionIsolator.ts"],"sourcesContent":["import type { TestAPI } from 'vitest';\n\n/**\n * Type definition for test fixtures that provide transaction access.\n * Used with Vitest's test.extend() API to inject transactions into tests.\n *\n * @template Transaction - The transaction type specific to the database driver\n * @template Extended - Additional context properties provided by the extend function\n */\nexport interface DatabaseFixtures<Transaction, Extended = object> {\n  /**\n   * The database transaction available to the test.\n   * All database operations should use this transaction to ensure proper rollback.\n   */\n  trx: Transaction;\n}\n\n/**\n * Combined fixtures type that merges the base transaction fixture with extended context.\n */\nexport type ExtendedDatabaseFixtures<\n  Transaction,\n  Extended = object,\n> = DatabaseFixtures<Transaction> & Extended;\n\n/**\n * Function type for extending test context with additional properties.\n * Receives the transaction and returns additional context to be merged with { trx }.\n *\n * @template Transaction - The transaction type\n * @template Extended - The type of additional context to provide\n *\n * @example\n * ```typescript\n * const extendContext: ExtendContextFn<Transaction<DB>, { factory: KyselyFactory }> =\n *   (trx) => ({ factory: new KyselyFactory(builders, seeds, trx) });\n * ```\n */\nexport type ExtendContextFn<Transaction, Extended> = (\n  trx: Transaction,\n) => Extended | Promise<Extended>;\n\n/**\n * PostgreSQL transaction isolation levels.\n * Controls the visibility of concurrent transactions.\n *\n * @see https://www.postgresql.org/docs/current/transaction-iso.html\n */\nexport enum IsolationLevel {\n  /**\n   * Lowest isolation level. Allows dirty reads.\n   * Not recommended for testing.\n   */\n  READ_UNCOMMITTED = 'READ UNCOMMITTED',\n  /**\n   * Default PostgreSQL isolation level.\n   * Prevents dirty reads but allows non-repeatable reads.\n   */\n  READ_COMMITTED = 'READ COMMITTED',\n  /**\n   * Prevents dirty reads and non-repeatable reads.\n   * Recommended for most test scenarios.\n   */\n  REPEATABLE_READ = 'REPEATABLE READ',\n  /**\n   * Highest isolation level. Prevents all phenomena.\n   * May cause performance overhead in tests.\n   */\n  SERIALIZABLE = 'SERIALIZABLE',\n}\n\n/**\n * Abstract base class for implementing database transaction isolation in Vitest tests.\n * Provides automatic transaction rollback after each test to maintain test isolation.\n * Subclasses must implement the transact() method for their specific database driver.\n *\n * @template TConn - The database connection type\n * @template Transaction - The transaction type\n *\n * @example\n * ```typescript\n * // Implement for your database driver\n * class MyDatabaseIsolator extends VitestPostgresTransactionIsolator<MyDB, MyTx> {\n *   async transact(conn: MyDB, level: IsolationLevel, fn: (tx: MyTx) => Promise<void>) {\n *     await conn.transaction(level, fn);\n *   }\n * }\n *\n * // Use in tests\n * const isolator = new MyDatabaseIsolator(test);\n * const isolatedTest = isolator.wrapVitestWithTransaction(db);\n *\n * isolatedTest('should create user', async ({ trx }) => {\n *   await trx.insert('users', { name: 'Test' });\n *   // Data is automatically rolled back after test\n * });\n * ```\n */\nexport abstract class VitestPostgresTransactionIsolator<TConn, Transaction> {\n  /**\n   * Abstract method to create a transaction with the specified isolation level.\n   * Must be implemented by subclasses for specific database drivers.\n   *\n   * @param conn - The database connection\n   * @param isolationLevel - The transaction isolation level\n   * @param fn - The function to execute within the transaction\n   * @returns Promise that resolves when the transaction completes\n   */\n  abstract transact(\n    conn: TConn,\n    isolationLevel: IsolationLevel,\n    fn: (trx: Transaction) => Promise<void>,\n  ): Promise<void>;\n\n  abstract destroy(conn: TConn): Promise<void>;\n  /**\n   * Creates a new VitestPostgresTransactionIsolator instance.\n   *\n   * @param api - The Vitest test API (usually the `test` export from vitest)\n   */\n  constructor(private readonly api: TestAPI) {}\n\n  /**\n   * Creates a wrapped version of Vitest's test API that provides transaction isolation.\n   * Each test will run within a database transaction that is automatically rolled back.\n   *\n   * @param options - Configuration options for transaction wrapping\n   * @returns A wrapped test API with transaction support\n   *\n   * @example\n   * ```typescript\n   * const isolatedTest = isolator.wrapVitestWithTransaction({\n   *   connection: db,\n   *   setup: async (trx) => {\n   *     await trx.insert('settings', { key: 'test', value: 'true' });\n   *   },\n   *   fixtures: {\n   *     factory: (trx) => new Factory(trx),\n   *   },\n   * });\n   *\n   * isolatedTest('test with transaction', async ({ trx, factory }) => {\n   *   const user = await factory.insert('user', { name: 'Test' });\n   *   expect(user).toBeDefined();\n   * });\n   * ```\n   */\n  wrapVitestWithTransaction<Extended extends Record<string, unknown> = {}>(\n    options: TransactionWrapperOptions<TConn, Transaction, Extended>,\n  ) {\n    const {\n      connection,\n      setup,\n      isolationLevel = IsolationLevel.REPEATABLE_READ,\n      fixtures,\n    } = options;\n\n    // Build fixture definitions for additional fixtures that depend on trx\n    const additionalFixtures: Record<string, unknown> = {};\n    if (fixtures) {\n      for (const [key, creator] of Object.entries(fixtures)) {\n        additionalFixtures[key] = async (\n          { trx }: { trx: Transaction },\n          use: (value: unknown) => Promise<void>,\n        ) => {\n          const value = await (creator as (trx: Transaction) => unknown)(trx);\n          await use(value);\n        };\n      }\n    }\n\n    type CombinedFixtures = DatabaseFixtures<Transaction> & Extended;\n\n    // Cast to bypass Vitest's strict fixture typing which can't infer\n    // dynamically built fixture objects\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    const extendFn = this.api.extend as <T>(fixtures: any) => TestAPI<T>;\n\n    return extendFn<CombinedFixtures>({\n      // This fixture automatically provides a transaction to each test\n      trx: async ({}, use: (value: Transaction) => Promise<void>) => {\n        // Create a custom error class for rollback\n        class TestRollback extends Error {\n          constructor() {\n            super('Test rollback');\n            this.name = 'TestRollback';\n          }\n        }\n\n        let testError: Error | undefined;\n        const conn = await connection();\n        try {\n          await this.transact(conn, isolationLevel, async (transaction) => {\n            try {\n              // Provide the transaction to the test\n              await setup?.(transaction);\n              await use(transaction);\n            } catch (error) {\n              // Capture any test errors\n              testError = error as Error;\n            }\n\n            // Always throw to trigger rollback\n            throw new TestRollback();\n          });\n        } catch (error) {\n          // Only rethrow if it's not our rollback error\n          if (!(error instanceof TestRollback)) {\n            throw error;\n          }\n\n          // If the test had an error, throw it now\n          if (testError) {\n            throw testError;\n          }\n        } finally {\n          await this.destroy(conn);\n        }\n      },\n      ...additionalFixtures,\n    });\n  }\n}\n\nexport type DatabaseConnectionFn<Conn> = () => Conn | Promise<Conn>;\nexport type DatabaseConnection<Conn> = DatabaseConnectionFn<Conn>;\n\n/**\n * Options for wrapping Vitest tests with database transaction isolation.\n */\nexport interface TransactionWrapperOptions<\n  TConn,\n  Transaction,\n  Extended extends Record<string, unknown> = {},\n> {\n  /** Function that creates or returns a database connection */\n  connection: DatabaseConnection<TConn>;\n  /** Optional setup function to run within the transaction before each test */\n  setup?: (trx: Transaction) => Promise<void>;\n  /** Transaction isolation level (defaults to REPEATABLE_READ) */\n  isolationLevel?: IsolationLevel;\n  /** Additional fixtures that depend on the transaction */\n  fixtures?: FixtureCreators<Transaction, Extended>;\n}\n\n/**\n * Type for fixture creator functions that depend on the transaction.\n * Each function receives the transaction and returns the fixture value.\n */\nexport type FixtureCreators<\n  Transaction,\n  Extended extends Record<string, unknown>,\n> = {\n  [K in keyof Extended]: (\n    trx: Transaction,\n  ) => Extended[K] | Promise<Extended[K]>;\n};\n\n/**\n * The test API returned by extendWithFixtures.\n * Provides access to both the transaction (trx) and all extended fixtures.\n *\n * @template Transaction - The transaction type\n * @template Extended - The type of additional fixtures provided\n * @template BaseTest - The base wrapped test type\n */\nexport type TestWithExtendedFixtures<\n  Transaction,\n  Extended extends Record<string, unknown>,\n  BaseTest extends ReturnType<TestAPI['extend']> = ReturnType<\n    TestAPI['extend']\n  >,\n> = BaseTest & {\n  <C extends object>(\n    name: string,\n    fn: (\n      context: DatabaseFixtures<Transaction> & Extended & C,\n    ) => Promise<void>,\n  ): void;\n  <C extends object>(\n    name: string,\n    options: object,\n    fn: (\n      context: DatabaseFixtures<Transaction> & Extended & C,\n    ) => Promise<void>,\n  ): void;\n};\n\n/**\n * Extends a wrapped test API with additional fixtures that depend on the transaction.\n * This allows composing test context with factories, repositories, or other helpers.\n *\n * @template Transaction - The transaction type\n * @template Extended - The type of additional context to provide\n * @param wrappedTest - The base wrapped test from wrapVitestWithTransaction\n * @param fixtures - Object mapping fixture names to creator functions\n * @returns An extended test API with both trx and the additional fixtures\n *\n * @example\n * ```typescript\n * import { wrapVitestKyselyTransaction, extendWithFixtures } from '@geekmidas/testkit/kysely';\n *\n * // Create base wrapped test\n * const baseTest = wrapVitestKyselyTransaction(test, {\n *   connection: db,\n *   setup: createTestTables,\n * });\n *\n * // Extend with fixtures\n * const it = extendWithFixtures(baseTest, {\n *   factory: (trx) => new KyselyFactory(builders, seeds, trx),\n *   userRepo: (trx) => new UserRepository(trx),\n * });\n *\n * // Use in tests - trx and all fixtures are available\n * it('should create user with factory', async ({ trx, factory, userRepo }) => {\n *   const user = await factory.insert('user', { name: 'Test' });\n *   expect(user).toBeDefined();\n * });\n * ```\n */\nexport function extendWithFixtures<\n  Transaction,\n  Extended extends Record<string, unknown>,\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  T extends ReturnType<TestAPI['extend']> = any,\n>(\n  wrappedTest: T,\n  fixtures: FixtureCreators<Transaction, Extended>,\n): TestWithExtendedFixtures<Transaction, Extended, T> {\n  // Build fixture definitions for Vitest's extend API\n  const fixtureDefinitions: Record<string, any> = {};\n\n  for (const [key, creator] of Object.entries(fixtures)) {\n    fixtureDefinitions[key] = async (\n      { trx }: { trx: Transaction },\n      use: (value: unknown) => Promise<void>,\n    ) => {\n      const value = await (creator as (trx: Transaction) => unknown)(trx);\n      await use(value);\n    };\n  }\n\n  return (wrappedTest as any).extend(fixtureDefinitions);\n}\n"],"mappings":";;;;;;;AAgDA,IAAY,4DAAL;;;;;AAKL;;;;;AAKA;;;;;AAKA;;;;;AAKA;;AACD;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6BD,IAAsB,oCAAtB,MAA4E;;;;;;CAsB1E,YAA6BA,KAAc;EAAd;CAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;CA2B7C,0BACEC,SACA;EACA,MAAM,EACJ,YACA,OACA,iBAAiB,eAAe,iBAChC,UACD,GAAG;EAGJ,MAAMC,qBAA8C,CAAE;AACtD,MAAI,SACF,MAAK,MAAM,CAAC,KAAK,QAAQ,IAAI,OAAO,QAAQ,SAAS,CACnD,oBAAmB,OAAO,OACxB,EAAE,KAA2B,EAC7BC,QACG;GACH,MAAM,QAAQ,MAAM,AAAC,QAA0C,IAAI;AACnE,SAAM,IAAI,MAAM;EACjB;EASL,MAAM,WAAW,KAAK,IAAI;AAE1B,SAAO,SAA2B;GAEhC,KAAK,OAAO,EAAE,EAAEC,QAA+C;IAE7D,MAAM,qBAAqB,MAAM;KAC/B,cAAc;AACZ,YAAM,gBAAgB;AACtB,WAAK,OAAO;KACb;IACF;IAED,IAAIC;IACJ,MAAM,OAAO,MAAM,YAAY;AAC/B,QAAI;AACF,WAAM,KAAK,SAAS,MAAM,gBAAgB,OAAO,gBAAgB;AAC/D,UAAI;AAEF,aAAM,QAAQ,YAAY;AAC1B,aAAM,IAAI,YAAY;MACvB,SAAQ,OAAO;AAEd,mBAAY;MACb;AAGD,YAAM,IAAI;KACX,EAAC;IACH,SAAQ,OAAO;AAEd,WAAM,iBAAiB,cACrB,OAAM;AAIR,SAAI,UACF,OAAM;IAET,UAAS;AACR,WAAM,KAAK,QAAQ,KAAK;IACzB;GACF;GACD,GAAG;EACJ,EAAC;CACH;AACF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAmGD,SAAgB,mBAMdC,aACAC,UACoD;CAEpD,MAAMC,qBAA0C,CAAE;AAElD,MAAK,MAAM,CAAC,KAAK,QAAQ,IAAI,OAAO,QAAQ,SAAS,CACnD,oBAAmB,OAAO,OACxB,EAAE,KAA2B,EAC7BL,QACG;EACH,MAAM,QAAQ,MAAM,AAAC,QAA0C,IAAI;AACnE,QAAM,IAAI,MAAM;CACjB;AAGH,QAAO,AAAC,YAAoB,OAAO,mBAAmB;AACvD"}

package/dist/VitestTransactionIsolator.cjs

@@ -1,4 +1,4 @@
-const require_VitestTransactionIsolator = require('./VitestTransactionIsolator-BKIrj3Uy.cjs');
+const require_VitestTransactionIsolator = require('./VitestTransactionIsolator-CMfJXZP8.cjs');
 
 exports.IsolationLevel = require_VitestTransactionIsolator.IsolationLevel;
 exports.VitestPostgresTransactionIsolator = require_VitestTransactionIsolator.VitestPostgresTransactionIsolator;

package/dist/VitestTransactionIsolator.d.cts

@@ -1,2 +1,2 @@
-import { DatabaseConnection, DatabaseConnectionFn, DatabaseFixtures, ExtendContextFn, ExtendedDatabaseFixtures, FixtureCreators, IsolationLevel, TestWithExtendedFixtures, VitestPostgresTransactionIsolator, extendWithFixtures } from "./VitestTransactionIsolator-DfA80g2M.cjs";
-export { DatabaseConnection, DatabaseConnectionFn, DatabaseFixtures, ExtendContextFn, ExtendedDatabaseFixtures, FixtureCreators, IsolationLevel, TestWithExtendedFixtures, VitestPostgresTransactionIsolator, extendWithFixtures };
+import { DatabaseConnection, DatabaseConnectionFn, DatabaseFixtures, ExtendContextFn, ExtendedDatabaseFixtures, FixtureCreators, IsolationLevel, TestWithExtendedFixtures, TransactionWrapperOptions, VitestPostgresTransactionIsolator, extendWithFixtures } from "./VitestTransactionIsolator-CwQaxZLP.cjs";
+export { DatabaseConnection, DatabaseConnectionFn, DatabaseFixtures, ExtendContextFn, ExtendedDatabaseFixtures, FixtureCreators, IsolationLevel, TestWithExtendedFixtures, TransactionWrapperOptions, VitestPostgresTransactionIsolator, extendWithFixtures };

package/dist/VitestTransactionIsolator.d.mts

@@ -1,2 +1,2 @@
-import { DatabaseConnection, DatabaseConnectionFn, DatabaseFixtures, ExtendContextFn, ExtendedDatabaseFixtures, FixtureCreators, IsolationLevel, TestWithExtendedFixtures, VitestPostgresTransactionIsolator, extendWithFixtures } from "./VitestTransactionIsolator-DLdQlfZ5.mjs";
-export { DatabaseConnection, DatabaseConnectionFn, DatabaseFixtures, ExtendContextFn, ExtendedDatabaseFixtures, FixtureCreators, IsolationLevel, TestWithExtendedFixtures, VitestPostgresTransactionIsolator, extendWithFixtures };
+import { DatabaseConnection, DatabaseConnectionFn, DatabaseFixtures, ExtendContextFn, ExtendedDatabaseFixtures, FixtureCreators, IsolationLevel, TestWithExtendedFixtures, TransactionWrapperOptions, VitestPostgresTransactionIsolator, extendWithFixtures } from "./VitestTransactionIsolator-BvR19bYn.mjs";
+export { DatabaseConnection, DatabaseConnectionFn, DatabaseFixtures, ExtendContextFn, ExtendedDatabaseFixtures, FixtureCreators, IsolationLevel, TestWithExtendedFixtures, TransactionWrapperOptions, VitestPostgresTransactionIsolator, extendWithFixtures };

package/dist/VitestTransactionIsolator.mjs

@@ -1,3 +1,3 @@
-import { IsolationLevel, VitestPostgresTransactionIsolator, extendWithFixtures } from "./VitestTransactionIsolator-BIaMs4c2.mjs";
+import { IsolationLevel, VitestPostgresTransactionIsolator, extendWithFixtures } from "./VitestTransactionIsolator-DQ7tLqgV.mjs";
 
 export { IsolationLevel, VitestPostgresTransactionIsolator, extendWithFixtures };

package/dist/benchmark.cjs

@@ -0,0 +1,49 @@
+
+//#region src/benchmark.ts
+/**
+* Generates an array of test records for benchmark data sets.
+*
+* @param count - Number of records to generate
+* @returns Array of test data objects
+*/
+function generateTestData(count) {
+	return Array.from({ length: count }, (_, i) => ({
+		id: `id-${i}`,
+		name: `Item ${i}`,
+		value: Math.random() * 1e3
+	}));
+}
+/**
+* Generates unique keys for cache benchmarks to avoid collisions.
+*
+* @param prefix - Key prefix
+* @param count - Number of keys to generate
+* @returns Array of unique cache keys
+*/
+function generateCacheKeys(prefix, count) {
+	return Array.from({ length: count }, (_, i) => `${prefix}:${i}`);
+}
+/**
+* Generates IP addresses for rate limit benchmarks.
+*
+* @param count - Number of IPs to generate
+* @param subnet - Subnet prefix (default: '192.168.1')
+* @returns Array of IP addresses
+*/
+function generateIpAddresses(count, subnet = "192.168.1") {
+	return Array.from({ length: count }, (_, i) => `${subnet}.${i % 256}`);
+}
+/**
+* Creates a random IP address for rate limit benchmarks.
+*/
+function randomIpAddress() {
+	const octet = () => Math.floor(Math.random() * 256);
+	return `${octet()}.${octet()}.${octet()}.${octet()}`;
+}
+
+//#endregion
+exports.generateCacheKeys = generateCacheKeys;
+exports.generateIpAddresses = generateIpAddresses;
+exports.generateTestData = generateTestData;
+exports.randomIpAddress = randomIpAddress;
+//# sourceMappingURL=benchmark.cjs.map

package/dist/benchmark.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"benchmark.cjs","names":["count: number","prefix: string","subnet: string"],"sources":["../src/benchmark.ts"],"sourcesContent":["/**\n * Generates an array of test records for benchmark data sets.\n *\n * @param count - Number of records to generate\n * @returns Array of test data objects\n */\nexport function generateTestData(\n  count: number,\n): Array<{ id: string; name: string; value: number }> {\n  return Array.from({ length: count }, (_, i) => ({\n    id: `id-${i}`,\n    name: `Item ${i}`,\n    value: Math.random() * 1000,\n  }));\n}\n\n/**\n * Generates unique keys for cache benchmarks to avoid collisions.\n *\n * @param prefix - Key prefix\n * @param count - Number of keys to generate\n * @returns Array of unique cache keys\n */\nexport function generateCacheKeys(prefix: string, count: number): string[] {\n  return Array.from({ length: count }, (_, i) => `${prefix}:${i}`);\n}\n\n/**\n * Generates IP addresses for rate limit benchmarks.\n *\n * @param count - Number of IPs to generate\n * @param subnet - Subnet prefix (default: '192.168.1')\n * @returns Array of IP addresses\n */\nexport function generateIpAddresses(\n  count: number,\n  subnet: string = '192.168.1',\n): string[] {\n  return Array.from({ length: count }, (_, i) => `${subnet}.${i % 256}`);\n}\n\n/**\n * Creates a random IP address for rate limit benchmarks.\n */\nexport function randomIpAddress(): string {\n  const octet = () => Math.floor(Math.random() * 256);\n  return `${octet()}.${octet()}.${octet()}.${octet()}`;\n}\n"],"mappings":";;;;;;;;AAMA,SAAgB,iBACdA,OACoD;AACpD,QAAO,MAAM,KAAK,EAAE,QAAQ,MAAO,GAAE,CAAC,GAAG,OAAO;EAC9C,KAAK,KAAK,EAAE;EACZ,OAAO,OAAO,EAAE;EAChB,OAAO,KAAK,QAAQ,GAAG;CACxB,GAAE;AACJ;;;;;;;;AASD,SAAgB,kBAAkBC,QAAgBD,OAAyB;AACzE,QAAO,MAAM,KAAK,EAAE,QAAQ,MAAO,GAAE,CAAC,GAAG,OAAO,EAAE,OAAO,GAAG,EAAE,EAAE;AACjE;;;;;;;;AASD,SAAgB,oBACdA,OACAE,SAAiB,aACP;AACV,QAAO,MAAM,KAAK,EAAE,QAAQ,MAAO,GAAE,CAAC,GAAG,OAAO,EAAE,OAAO,GAAG,IAAI,IAAI,EAAE;AACvE;;;;AAKD,SAAgB,kBAA0B;CACxC,MAAM,QAAQ,MAAM,KAAK,MAAM,KAAK,QAAQ,GAAG,IAAI;AACnD,SAAQ,EAAE,OAAO,CAAC,GAAG,OAAO,CAAC,GAAG,OAAO,CAAC,GAAG,OAAO,CAAC;AACpD"}

package/dist/benchmark.d.cts

@@ -0,0 +1,35 @@
+//#region src/benchmark.d.ts
+/**
+ * Generates an array of test records for benchmark data sets.
+ *
+ * @param count - Number of records to generate
+ * @returns Array of test data objects
+ */
+declare function generateTestData(count: number): Array<{
+  id: string;
+  name: string;
+  value: number;
+}>;
+/**
+ * Generates unique keys for cache benchmarks to avoid collisions.
+ *
+ * @param prefix - Key prefix
+ * @param count - Number of keys to generate
+ * @returns Array of unique cache keys
+ */
+declare function generateCacheKeys(prefix: string, count: number): string[];
+/**
+ * Generates IP addresses for rate limit benchmarks.
+ *
+ * @param count - Number of IPs to generate
+ * @param subnet - Subnet prefix (default: '192.168.1')
+ * @returns Array of IP addresses
+ */
+declare function generateIpAddresses(count: number, subnet?: string): string[];
+/**
+ * Creates a random IP address for rate limit benchmarks.
+ */
+declare function randomIpAddress(): string;
+//#endregion
+export { generateCacheKeys, generateIpAddresses, generateTestData, randomIpAddress };
+//# sourceMappingURL=benchmark.d.cts.map

package/dist/benchmark.d.mts

@@ -0,0 +1,35 @@
+//#region src/benchmark.d.ts
+/**
+ * Generates an array of test records for benchmark data sets.
+ *
+ * @param count - Number of records to generate
+ * @returns Array of test data objects
+ */
+declare function generateTestData(count: number): Array<{
+  id: string;
+  name: string;
+  value: number;
+}>;
+/**
+ * Generates unique keys for cache benchmarks to avoid collisions.
+ *
+ * @param prefix - Key prefix
+ * @param count - Number of keys to generate
+ * @returns Array of unique cache keys
+ */
+declare function generateCacheKeys(prefix: string, count: number): string[];
+/**
+ * Generates IP addresses for rate limit benchmarks.
+ *
+ * @param count - Number of IPs to generate
+ * @param subnet - Subnet prefix (default: '192.168.1')
+ * @returns Array of IP addresses
+ */
+declare function generateIpAddresses(count: number, subnet?: string): string[];
+/**
+ * Creates a random IP address for rate limit benchmarks.
+ */
+declare function randomIpAddress(): string;
+//#endregion
+export { generateCacheKeys, generateIpAddresses, generateTestData, randomIpAddress };
+//# sourceMappingURL=benchmark.d.mts.map

package/dist/benchmark.mjs

@@ -0,0 +1,45 @@
+//#region src/benchmark.ts
+/**
+* Generates an array of test records for benchmark data sets.
+*
+* @param count - Number of records to generate
+* @returns Array of test data objects
+*/
+function generateTestData(count) {
+	return Array.from({ length: count }, (_, i) => ({
+		id: `id-${i}`,
+		name: `Item ${i}`,
+		value: Math.random() * 1e3
+	}));
+}
+/**
+* Generates unique keys for cache benchmarks to avoid collisions.
+*
+* @param prefix - Key prefix
+* @param count - Number of keys to generate
+* @returns Array of unique cache keys
+*/
+function generateCacheKeys(prefix, count) {
+	return Array.from({ length: count }, (_, i) => `${prefix}:${i}`);
+}
+/**
+* Generates IP addresses for rate limit benchmarks.
+*
+* @param count - Number of IPs to generate
+* @param subnet - Subnet prefix (default: '192.168.1')
+* @returns Array of IP addresses
+*/
+function generateIpAddresses(count, subnet = "192.168.1") {
+	return Array.from({ length: count }, (_, i) => `${subnet}.${i % 256}`);
+}
+/**
+* Creates a random IP address for rate limit benchmarks.
+*/
+function randomIpAddress() {
+	const octet = () => Math.floor(Math.random() * 256);
+	return `${octet()}.${octet()}.${octet()}.${octet()}`;
+}
+
+//#endregion
+export { generateCacheKeys, generateIpAddresses, generateTestData, randomIpAddress };
+//# sourceMappingURL=benchmark.mjs.map

package/dist/benchmark.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"benchmark.mjs","names":["count: number","prefix: string","subnet: string"],"sources":["../src/benchmark.ts"],"sourcesContent":["/**\n * Generates an array of test records for benchmark data sets.\n *\n * @param count - Number of records to generate\n * @returns Array of test data objects\n */\nexport function generateTestData(\n  count: number,\n): Array<{ id: string; name: string; value: number }> {\n  return Array.from({ length: count }, (_, i) => ({\n    id: `id-${i}`,\n    name: `Item ${i}`,\n    value: Math.random() * 1000,\n  }));\n}\n\n/**\n * Generates unique keys for cache benchmarks to avoid collisions.\n *\n * @param prefix - Key prefix\n * @param count - Number of keys to generate\n * @returns Array of unique cache keys\n */\nexport function generateCacheKeys(prefix: string, count: number): string[] {\n  return Array.from({ length: count }, (_, i) => `${prefix}:${i}`);\n}\n\n/**\n * Generates IP addresses for rate limit benchmarks.\n *\n * @param count - Number of IPs to generate\n * @param subnet - Subnet prefix (default: '192.168.1')\n * @returns Array of IP addresses\n */\nexport function generateIpAddresses(\n  count: number,\n  subnet: string = '192.168.1',\n): string[] {\n  return Array.from({ length: count }, (_, i) => `${subnet}.${i % 256}`);\n}\n\n/**\n * Creates a random IP address for rate limit benchmarks.\n */\nexport function randomIpAddress(): string {\n  const octet = () => Math.floor(Math.random() * 256);\n  return `${octet()}.${octet()}.${octet()}.${octet()}`;\n}\n"],"mappings":";;;;;;;AAMA,SAAgB,iBACdA,OACoD;AACpD,QAAO,MAAM,KAAK,EAAE,QAAQ,MAAO,GAAE,CAAC,GAAG,OAAO;EAC9C,KAAK,KAAK,EAAE;EACZ,OAAO,OAAO,EAAE;EAChB,OAAO,KAAK,QAAQ,GAAG;CACxB,GAAE;AACJ;;;;;;;;AASD,SAAgB,kBAAkBC,QAAgBD,OAAyB;AACzE,QAAO,MAAM,KAAK,EAAE,QAAQ,MAAO,GAAE,CAAC,GAAG,OAAO,EAAE,OAAO,GAAG,EAAE,EAAE;AACjE;;;;;;;;AASD,SAAgB,oBACdA,OACAE,SAAiB,aACP;AACV,QAAO,MAAM,KAAK,EAAE,QAAQ,MAAO,GAAE,CAAC,GAAG,OAAO,EAAE,OAAO,GAAG,IAAI,IAAI,EAAE;AACvE;;;;AAKD,SAAgB,kBAA0B;CACxC,MAAM,QAAQ,MAAM,KAAK,MAAM,KAAK,QAAQ,GAAG,IAAI;AACnD,SAAQ,EAAE,OAAO,CAAC,GAAG,OAAO,CAAC,GAAG,OAAO,CAAC,GAAG,OAAO,CAAC;AACpD"}

package/dist/better-auth.d.cts

@@ -1,4 +1,4 @@
-import * as better_auth_adapters1 from "better-auth/adapters";
+import * as better_auth_adapters0 from "better-auth/adapters";
 import { DBAdapterDebugLogOption } from "better-auth/adapters";
 
 //#region src/better-auth.d.ts
@@ -7,7 +7,7 @@ interface MemoryAdapterConfig {
   usePlural?: boolean;
   initialData?: Record<string, any[]>;
 }
-declare const memoryAdapter: (config?: MemoryAdapterConfig, store?: Map<any, any>) => better_auth_adapters1.AdapterFactory & {
+declare const memoryAdapter: (config?: MemoryAdapterConfig, store?: Map<any, any>) => better_auth_adapters0.AdapterFactory & {
   clear: () => void;
   getAllData: () => Record<string, any[]>;
   getStore: () => Map<any, any>;

package/dist/better-auth.d.mts

@@ -1,4 +1,4 @@
-import * as better_auth_adapters4 from "better-auth/adapters";
+import * as better_auth_adapters0 from "better-auth/adapters";
 import { DBAdapterDebugLogOption } from "better-auth/adapters";
 
 //#region src/better-auth.d.ts
@@ -7,7 +7,7 @@ interface MemoryAdapterConfig {
   usePlural?: boolean;
   initialData?: Record<string, any[]>;
 }
-declare const memoryAdapter: (config?: MemoryAdapterConfig, store?: Map<any, any>) => better_auth_adapters4.AdapterFactory & {
+declare const memoryAdapter: (config?: MemoryAdapterConfig, store?: Map<any, any>) => better_auth_adapters0.AdapterFactory & {
   clear: () => void;
   getAllData: () => Record<string, any[]>;
   getStore: () => Map<any, any>;

package/dist/{directory-Q178x53k.d.mts → directory-BXavAeJZ.d.mts}

@@ -1,7 +1,7 @@
-import * as vitest3 from "vitest";
+import * as vitest6 from "vitest";
 
 //#region src/os/directory.d.ts
-declare const itWithDir: vitest3.TestAPI<{
+declare const itWithDir: vitest6.TestAPI<{
   dir: string;
 }>;
 interface DirectoryFixtures {
@@ -9,4 +9,4 @@ interface DirectoryFixtures {
 }
 //#endregion
 export { DirectoryFixtures, itWithDir };
-//# sourceMappingURL=directory-Q178x53k.d.mts.map
+//# sourceMappingURL=directory-BXavAeJZ.d.mts.map