@geekmidas/testkit 0.0.15 → 0.0.16

package/dist/{PostgresObjectionMigrator-G4h5FLvU.mjs → PostgresObjectionMigrator-DPj2pOpX.mjs}

@@ -1,4 +1,4 @@
-import { PostgresMigrator } from "./PostgresMigrator-DxPC_gGu.mjs";
+import { PostgresMigrator } from "./PostgresMigrator-DbuJGAVy.mjs";
 
 //#region src/PostgresObjectionMigrator.ts
 /**
@@ -114,4 +114,5 @@ var PostgresObjectionMigrator = class extends PostgresMigrator {
 };
 
 //#endregion
-export { PostgresObjectionMigrator };
+export { PostgresObjectionMigrator };
+//# sourceMappingURL=PostgresObjectionMigrator-DPj2pOpX.mjs.map

package/dist/PostgresObjectionMigrator-DPj2pOpX.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"PostgresObjectionMigrator-DPj2pOpX.mjs","names":["options: {\n      uri: string;\n      knex: Knex;\n    }","migration: string"],"sources":["../src/PostgresObjectionMigrator.ts"],"sourcesContent":["import type { Knex } from 'knex';\nimport { PostgresMigrator } from './PostgresMigrator';\n\n/**\n * Default logger instance for migration operations.\n */\nconst logger = console;\n\n/**\n * PostgreSQL migrator implementation for Objection.js ORM with Knex.\n * Extends PostgresMigrator to provide Knex-specific migration functionality.\n * Automatically creates test databases and applies migrations for testing environments.\n *\n * @example\n * ```typescript\n * import knex from 'knex';\n * import { PostgresObjectionMigrator } from '@geekmidas/testkit';\n *\n * // Create Knex instance\n * const db = knex({\n *   client: 'pg',\n *   connection: uri,\n *   migrations: {\n *     directory: path.join(__dirname, 'migrations'),\n *     extension: 'ts'\n *   }\n * });\n *\n * // Create and use migrator\n * const migrator = new PostgresObjectionMigrator({\n *   uri: 'postgresql://localhost:5432/test_db',\n *   knex: db\n * });\n *\n * const cleanup = await migrator.start();\n * // Run tests...\n * await cleanup();\n * ```\n */\nexport class PostgresObjectionMigrator extends PostgresMigrator {\n  /**\n   * Creates a new PostgresObjectionMigrator instance.\n   *\n   * @param options - Configuration options\n   * @param options.uri - PostgreSQL connection URI\n   * @param options.knex - Knex database instance configured with migrations\n   */\n  constructor(\n    private options: {\n      uri: string;\n      knex: Knex;\n    },\n  ) {\n    super(options.uri);\n  }\n\n  /**\n   * Executes Knex migrations to the latest version.\n   * Implements the abstract migrate() method from PostgresMigrator.\n   *\n   * @throws Error if migrations fail to apply\n   * @returns Promise that resolves when all migrations are applied\n   */\n  async migrate(): Promise<void> {\n    try {\n      // Run migrations to latest\n      const [batchNo, migrations] = await this.options.knex.migrate.latest();\n\n      if (migrations.length > 0) {\n        logger.log(\n          `Applied batch ${batchNo} with ${migrations.length} migrations:`,\n        );\n        migrations.forEach((migration: string) => {\n          logger.log(`  - ${migration}`);\n        });\n      } else {\n        logger.log('No pending migrations to apply');\n      }\n    } catch (error) {\n      logger.error('Failed to apply migrations:', error);\n      throw error;\n    } finally {\n      // Always destroy the connection pool\n      await this.options.knex.destroy();\n    }\n  }\n\n  /**\n   * Rolls back the last batch of migrations.\n   * Useful for testing migration rollback scenarios.\n   *\n   * @returns Promise that resolves when rollback is complete\n   */\n  async rollback(): Promise<void> {\n    try {\n      const [batchNo, migrations] = await this.options.knex.migrate.rollback();\n\n      if (migrations.length > 0) {\n        logger.log(\n          `Rolled back batch ${batchNo} with ${migrations.length} migrations:`,\n        );\n        migrations.forEach((migration: string) => {\n          logger.log(`  - ${migration}`);\n        });\n      } else {\n        logger.log('No migrations to rollback');\n      }\n    } catch (error) {\n      logger.error('Failed to rollback migrations:', error);\n      throw error;\n    } finally {\n      await this.options.knex.destroy();\n    }\n  }\n\n  /**\n   * Gets the current migration status.\n   * Returns information about completed and pending migrations.\n   *\n   * @returns Promise with migration status information\n   */\n  async status(): Promise<{\n    completed: string[];\n    pending: string[];\n  }> {\n    try {\n      const completed = await this.options.knex.migrate.list();\n      const [, pending] = await this.options.knex.migrate.currentVersion();\n\n      return {\n        completed: Array.isArray(completed[0]) ? completed[0] : [],\n        pending: Array.isArray(pending) ? pending : [],\n      };\n    } finally {\n      await this.options.knex.destroy();\n    }\n  }\n}\n"],"mappings":";;;;;;AAMA,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAiCf,IAAa,4BAAb,cAA+C,iBAAiB;;;;;;;;CAQ9D,YACUA,SAIR;AACA,QAAM,QAAQ,IAAI;EALV;CAMT;;;;;;;;CASD,MAAM,UAAyB;AAC7B,MAAI;GAEF,MAAM,CAAC,SAAS,WAAW,GAAG,MAAM,KAAK,QAAQ,KAAK,QAAQ,QAAQ;AAEtE,OAAI,WAAW,SAAS,GAAG;AACzB,WAAO,KACJ,gBAAgB,QAAQ,QAAQ,WAAW,OAAO,cACpD;AACD,eAAW,QAAQ,CAACC,cAAsB;AACxC,YAAO,KAAK,MAAM,UAAU,EAAE;IAC/B,EAAC;GACH,MACC,QAAO,IAAI,iCAAiC;EAE/C,SAAQ,OAAO;AACd,UAAO,MAAM,+BAA+B,MAAM;AAClD,SAAM;EACP,UAAS;AAER,SAAM,KAAK,QAAQ,KAAK,SAAS;EAClC;CACF;;;;;;;CAQD,MAAM,WAA0B;AAC9B,MAAI;GACF,MAAM,CAAC,SAAS,WAAW,GAAG,MAAM,KAAK,QAAQ,KAAK,QAAQ,UAAU;AAExE,OAAI,WAAW,SAAS,GAAG;AACzB,WAAO,KACJ,oBAAoB,QAAQ,QAAQ,WAAW,OAAO,cACxD;AACD,eAAW,QAAQ,CAACA,cAAsB;AACxC,YAAO,KAAK,MAAM,UAAU,EAAE;IAC/B,EAAC;GACH,MACC,QAAO,IAAI,4BAA4B;EAE1C,SAAQ,OAAO;AACd,UAAO,MAAM,kCAAkC,MAAM;AACrD,SAAM;EACP,UAAS;AACR,SAAM,KAAK,QAAQ,KAAK,SAAS;EAClC;CACF;;;;;;;CAQD,MAAM,SAGH;AACD,MAAI;GACF,MAAM,YAAY,MAAM,KAAK,QAAQ,KAAK,QAAQ,MAAM;GACxD,MAAM,GAAG,QAAQ,GAAG,MAAM,KAAK,QAAQ,KAAK,QAAQ,gBAAgB;AAEpE,UAAO;IACL,WAAW,MAAM,QAAQ,UAAU,GAAG,GAAG,UAAU,KAAK,CAAE;IAC1D,SAAS,MAAM,QAAQ,QAAQ,GAAG,UAAU,CAAE;GAC/C;EACF,UAAS;AACR,SAAM,KAAK,QAAQ,KAAK,SAAS;EAClC;CACF;AACF"}

package/dist/{PostgresObjectionMigrator-C69n7vzr.d.mts → PostgresObjectionMigrator-D_hCcrQu.d.mts}

@@ -1,4 +1,4 @@
-import { PostgresMigrator } from "./PostgresMigrator-BlvuQl7d.mjs";
+import { PostgresMigrator } from "./PostgresMigrator-DQaRxoaY.mjs";
 import { Knex } from "knex";
 
 //#region src/PostgresObjectionMigrator.d.ts
@@ -74,4 +74,5 @@ declare class PostgresObjectionMigrator extends PostgresMigrator {
   }>;
 }
 //#endregion
-export { PostgresObjectionMigrator };
+export { PostgresObjectionMigrator };
+//# sourceMappingURL=PostgresObjectionMigrator-D_hCcrQu.d.mts.map

package/dist/PostgresObjectionMigrator.d.mts

@@ -1,3 +1,3 @@
-import "./PostgresMigrator-BlvuQl7d.mjs";
-import { PostgresObjectionMigrator } from "./PostgresObjectionMigrator-C69n7vzr.mjs";
+import "./PostgresMigrator-DQaRxoaY.mjs";
+import { PostgresObjectionMigrator } from "./PostgresObjectionMigrator-D_hCcrQu.mjs";
 export { PostgresObjectionMigrator };

package/dist/PostgresObjectionMigrator.mjs

@@ -1,4 +1,4 @@
-import "./PostgresMigrator-DxPC_gGu.mjs";
-import { PostgresObjectionMigrator } from "./PostgresObjectionMigrator-G4h5FLvU.mjs";
+import "./PostgresMigrator-DbuJGAVy.mjs";
+import { PostgresObjectionMigrator } from "./PostgresObjectionMigrator-DPj2pOpX.mjs";
 
 export { PostgresObjectionMigrator };

package/dist/VitestKyselyTransactionIsolator-BxjlD1YM.mjs

@@ -56,4 +56,5 @@ var VitestKyselyTransactionIsolator = class extends VitestPostgresTransactionIso
 };
 
 //#endregion
-export { VitestKyselyTransactionIsolator };
+export { VitestKyselyTransactionIsolator };
+//# sourceMappingURL=VitestKyselyTransactionIsolator-BxjlD1YM.mjs.map

package/dist/VitestKyselyTransactionIsolator-BxjlD1YM.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"VitestKyselyTransactionIsolator-BxjlD1YM.mjs","names":["conn: Kysely<Database>","level: IsolationLevel","fn: (trx: Transaction<Database>) => Promise<void>"],"sources":["../src/VitestKyselyTransactionIsolator.ts"],"sourcesContent":["import type { Kysely, Transaction } from 'kysely';\nimport {\n  type IsolationLevel,\n  VitestPostgresTransactionIsolator,\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  Database,\n> extends VitestPostgresTransactionIsolator<\n  Kysely<Database>,\n  Transaction<Database>\n> {\n  async destroy(conn: Kysely<Database>): Promise<void> {\n    // return conn.destroy();\n  }\n  /**\n   * Creates a Kysely transaction with the specified isolation level.\n   * Implements the abstract transact method from VitestPostgresTransactionIsolator.\n   *\n   * @param conn - The Kysely database connection\n   * @param level - 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  async transact(\n    conn: Kysely<Database>,\n    level: IsolationLevel,\n    fn: (trx: Transaction<Database>) => Promise<void>,\n  ): Promise<void> {\n    const isolationLevel =\n      level.toLocaleLowerCase() as Lowercase<IsolationLevel>;\n    await conn.transaction().setIsolationLevel(isolationLevel).execute(fn);\n  }\n  // Implement any Kysely-specific transaction logic here\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA2CA,IAAa,kCAAb,cAEU,kCAGR;CACA,MAAM,QAAQA,MAAuC,CAEpD;;;;;;;;;;CAUD,MAAM,SACJA,MACAC,OACAC,IACe;EACf,MAAM,iBACJ,MAAM,mBAAmB;AAC3B,QAAM,KAAK,aAAa,CAAC,kBAAkB,eAAe,CAAC,QAAQ,GAAG;CACvE;AAEF"}

package/dist/{VitestKyselyTransactionIsolator-CnxpE9cH.d.mts → VitestKyselyTransactionIsolator-COCVfvfr.d.mts}

@@ -1,4 +1,4 @@
-import { IsolationLevel, VitestPostgresTransactionIsolator } from "./VitestTransactionIsolator-zdyiS_SY.mjs";
+import { IsolationLevel, VitestPostgresTransactionIsolator } from "./VitestTransactionIsolator-CsfJBxcb.mjs";
 import { Kysely, Transaction } from "kysely";
 
 //#region src/VitestKyselyTransactionIsolator.d.ts
@@ -54,4 +54,5 @@ declare class VitestKyselyTransactionIsolator<Database> extends VitestPostgresTr
   transact(conn: Kysely<Database>, level: IsolationLevel, fn: (trx: Transaction<Database>) => Promise<void>): Promise<void>;
 }
 //#endregion
-export { VitestKyselyTransactionIsolator };
+export { VitestKyselyTransactionIsolator };
+//# sourceMappingURL=VitestKyselyTransactionIsolator-COCVfvfr.d.mts.map

package/dist/VitestKyselyTransactionIsolator-Cst3vFjb.cjs

@@ -61,4 +61,5 @@ Object.defineProperty(exports, 'VitestKyselyTransactionIsolator', {
   get: function () {
     return VitestKyselyTransactionIsolator;
   }
-});
+});
+//# sourceMappingURL=VitestKyselyTransactionIsolator-Cst3vFjb.cjs.map

package/dist/VitestKyselyTransactionIsolator-Cst3vFjb.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"VitestKyselyTransactionIsolator-Cst3vFjb.cjs","names":["VitestPostgresTransactionIsolator","conn: Kysely<Database>","level: IsolationLevel","fn: (trx: Transaction<Database>) => Promise<void>"],"sources":["../src/VitestKyselyTransactionIsolator.ts"],"sourcesContent":["import type { Kysely, Transaction } from 'kysely';\nimport {\n  type IsolationLevel,\n  VitestPostgresTransactionIsolator,\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  Database,\n> extends VitestPostgresTransactionIsolator<\n  Kysely<Database>,\n  Transaction<Database>\n> {\n  async destroy(conn: Kysely<Database>): Promise<void> {\n    // return conn.destroy();\n  }\n  /**\n   * Creates a Kysely transaction with the specified isolation level.\n   * Implements the abstract transact method from VitestPostgresTransactionIsolator.\n   *\n   * @param conn - The Kysely database connection\n   * @param level - 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  async transact(\n    conn: Kysely<Database>,\n    level: IsolationLevel,\n    fn: (trx: Transaction<Database>) => Promise<void>,\n  ): Promise<void> {\n    const isolationLevel =\n      level.toLocaleLowerCase() as Lowercase<IsolationLevel>;\n    await conn.transaction().setIsolationLevel(isolationLevel).execute(fn);\n  }\n  // Implement any Kysely-specific transaction logic here\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA2CA,IAAa,kCAAb,cAEUA,oEAGR;CACA,MAAM,QAAQC,MAAuC,CAEpD;;;;;;;;;;CAUD,MAAM,SACJA,MACAC,OACAC,IACe;EACf,MAAM,iBACJ,MAAM,mBAAmB;AAC3B,QAAM,KAAK,aAAa,CAAC,kBAAkB,eAAe,CAAC,QAAQ,GAAG;CACvE;AAEF"}

package/dist/VitestKyselyTransactionIsolator-DYUYVEh9.d.cts

@@ -54,4 +54,5 @@ declare class VitestKyselyTransactionIsolator<Database> extends VitestPostgresTr
   transact(conn: Kysely<Database>, level: IsolationLevel, fn: (trx: Transaction<Database>) => Promise<void>): Promise<void>;
 }
 //#endregion
-export { VitestKyselyTransactionIsolator };
+export { VitestKyselyTransactionIsolator };
+//# sourceMappingURL=VitestKyselyTransactionIsolator-DYUYVEh9.d.cts.map

package/dist/VitestKyselyTransactionIsolator.d.mts

@@ -1,3 +1,3 @@
-import "./VitestTransactionIsolator-zdyiS_SY.mjs";
-import { VitestKyselyTransactionIsolator } from "./VitestKyselyTransactionIsolator-CnxpE9cH.mjs";
+import "./VitestTransactionIsolator-CsfJBxcb.mjs";
+import { VitestKyselyTransactionIsolator } from "./VitestKyselyTransactionIsolator-COCVfvfr.mjs";
 export { VitestKyselyTransactionIsolator };

package/dist/VitestObjectionTransactionIsolator-BU-jXEhz.mjs

@@ -59,4 +59,5 @@ var VitestObjectionTransactionIsolator = class extends VitestPostgresTransaction
 };
 
 //#endregion
-export { VitestObjectionTransactionIsolator };
+export { VitestObjectionTransactionIsolator };
+//# sourceMappingURL=VitestObjectionTransactionIsolator-BU-jXEhz.mjs.map

package/dist/VitestObjectionTransactionIsolator-BU-jXEhz.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"VitestObjectionTransactionIsolator-BU-jXEhz.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  type IsolationLevel,\n  VitestPostgresTransactionIsolator,\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  Knex,\n  Knex.Transaction\n> {\n  async destroy(conn: Knex<any, any[]>): Promise<void> {}\n  /**\n   * Creates a Knex transaction with the specified isolation level.\n   * Implements the abstract transact method from VitestPostgresTransactionIsolator.\n   * This transaction can be used with Objection.js models via Model.query(trx).\n   *\n   * @param conn - The Knex database connection\n   * @param level - 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   * @example\n   * ```typescript\n   * await isolator.transact(knex, IsolationLevel.REPEATABLE_READ, async (trx) => {\n   *   // Use transaction with Objection models\n   *   await User.query(trx).insert({ name: 'Test' });\n   *   await Post.query(trx).where('userId', user.id).delete();\n   * });\n   * ```\n   */\n  async transact(\n    connection: Knex,\n    level: IsolationLevel,\n    fn: (trx: Knex.Transaction) => Promise<void>,\n  ): Promise<void> {\n    const isolationLevel = level.toLowerCase() as Lowercase<IsolationLevel>;\n\n    await connection.transaction(\n      async (trx) => {\n        await fn(trx);\n      },\n      {\n        isolationLevel,\n      },\n    );\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkCA,IAAa,qCAAb,cAAwD,kCAGtD;CACA,MAAM,QAAQA,MAAuC,CAAE;;;;;;;;;;;;;;;;;;;;CAoBvD,MAAM,SACJC,YACAC,OACAC,IACe;EACf,MAAM,iBAAiB,MAAM,aAAa;AAE1C,QAAM,WAAW,YACf,OAAO,QAAQ;AACb,SAAM,GAAG,IAAI;EACd,GACD,EACE,eACD,EACF;CACF;AACF"}

package/dist/VitestObjectionTransactionIsolator-CJ4ds5Qv.d.cts

@@ -55,4 +55,5 @@ declare class VitestObjectionTransactionIsolator extends VitestPostgresTransacti
   transact(connection: Knex, level: IsolationLevel, fn: (trx: Knex.Transaction) => Promise<void>): Promise<void>;
 }
 //#endregion
-export { VitestObjectionTransactionIsolator };
+export { VitestObjectionTransactionIsolator };
+//# sourceMappingURL=VitestObjectionTransactionIsolator-CJ4ds5Qv.d.cts.map

package/dist/VitestObjectionTransactionIsolator-DzeF4UAq.cjs

@@ -64,4 +64,5 @@ Object.defineProperty(exports, 'VitestObjectionTransactionIsolator', {
   get: function () {
     return VitestObjectionTransactionIsolator;
   }
-});
+});
+//# sourceMappingURL=VitestObjectionTransactionIsolator-DzeF4UAq.cjs.map

package/dist/VitestObjectionTransactionIsolator-DzeF4UAq.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"VitestObjectionTransactionIsolator-DzeF4UAq.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  type IsolationLevel,\n  VitestPostgresTransactionIsolator,\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  Knex,\n  Knex.Transaction\n> {\n  async destroy(conn: Knex<any, any[]>): Promise<void> {}\n  /**\n   * Creates a Knex transaction with the specified isolation level.\n   * Implements the abstract transact method from VitestPostgresTransactionIsolator.\n   * This transaction can be used with Objection.js models via Model.query(trx).\n   *\n   * @param conn - The Knex database connection\n   * @param level - 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   * @example\n   * ```typescript\n   * await isolator.transact(knex, IsolationLevel.REPEATABLE_READ, async (trx) => {\n   *   // Use transaction with Objection models\n   *   await User.query(trx).insert({ name: 'Test' });\n   *   await Post.query(trx).where('userId', user.id).delete();\n   * });\n   * ```\n   */\n  async transact(\n    connection: Knex,\n    level: IsolationLevel,\n    fn: (trx: Knex.Transaction) => Promise<void>,\n  ): Promise<void> {\n    const isolationLevel = level.toLowerCase() as Lowercase<IsolationLevel>;\n\n    await connection.transaction(\n      async (trx) => {\n        await fn(trx);\n      },\n      {\n        isolationLevel,\n      },\n    );\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkCA,IAAa,qCAAb,cAAwDA,oEAGtD;CACA,MAAM,QAAQC,MAAuC,CAAE;;;;;;;;;;;;;;;;;;;;CAoBvD,MAAM,SACJC,YACAC,OACAC,IACe;EACf,MAAM,iBAAiB,MAAM,aAAa;AAE1C,QAAM,WAAW,YACf,OAAO,QAAQ;AACb,SAAM,GAAG,IAAI;EACd,GACD,EACE,eACD,EACF;CACF;AACF"}

package/dist/{VitestObjectionTransactionIsolator-DIM79dCq.d.mts → VitestObjectionTransactionIsolator-b973r9O1.d.mts}

@@ -1,4 +1,4 @@
-import { IsolationLevel, VitestPostgresTransactionIsolator } from "./VitestTransactionIsolator-zdyiS_SY.mjs";
+import { IsolationLevel, VitestPostgresTransactionIsolator } from "./VitestTransactionIsolator-CsfJBxcb.mjs";
 import { Knex } from "knex";
 
 //#region src/VitestObjectionTransactionIsolator.d.ts
@@ -55,4 +55,5 @@ declare class VitestObjectionTransactionIsolator extends VitestPostgresTransacti
   transact(connection: Knex, level: IsolationLevel, fn: (trx: Knex.Transaction) => Promise<void>): Promise<void>;
 }
 //#endregion
-export { VitestObjectionTransactionIsolator };
+export { VitestObjectionTransactionIsolator };
+//# sourceMappingURL=VitestObjectionTransactionIsolator-b973r9O1.d.mts.map

package/dist/VitestObjectionTransactionIsolator.d.mts

@@ -1,3 +1,3 @@
-import "./VitestTransactionIsolator-zdyiS_SY.mjs";
-import { VitestObjectionTransactionIsolator } from "./VitestObjectionTransactionIsolator-DIM79dCq.mjs";
+import "./VitestTransactionIsolator-CsfJBxcb.mjs";
+import { VitestObjectionTransactionIsolator } from "./VitestObjectionTransactionIsolator-b973r9O1.mjs";
 export { VitestObjectionTransactionIsolator };

package/dist/VitestTransactionIsolator-BQ5FpLtC.cjs

@@ -129,4 +129,5 @@ Object.defineProperty(exports, 'VitestPostgresTransactionIsolator', {
   get: function () {
     return VitestPostgresTransactionIsolator;
   }
-});
+});
+//# sourceMappingURL=VitestTransactionIsolator-BQ5FpLtC.cjs.map

package/dist/VitestTransactionIsolator-BQ5FpLtC.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"VitestTransactionIsolator-BQ5FpLtC.cjs","names":["api: TestAPI","createConnection: DatabaseConnection<TConn>","setup?: (trx: Transaction) => Promise<void>","level: IsolationLevel","testError: Error | undefined"],"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 */\nexport interface DatabaseFixtures<Transaction> {\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 * 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 conn - The database connection to use\n   * @param setup - Optional setup function to run within the transaction before each test\n   * @param level - The transaction isolation level (defaults to REPEATABLE_READ)\n   * @returns A wrapped test API with transaction support\n   *\n   * @example\n   * ```typescript\n   * const isolatedTest = isolator.wrapVitestWithTransaction(db, async (trx) => {\n   *   // Optional setup: create common test data\n   *   await trx.insert('settings', { key: 'test', value: 'true' });\n   * });\n   *\n   * isolatedTest('test with transaction', async ({ trx }) => {\n   *   const user = await trx.insert('users', { name: 'Test' });\n   *   expect(user).toBeDefined();\n   * });\n   * ```\n   */\n  wrapVitestWithTransaction(\n    createConnection: DatabaseConnection<TConn>,\n    setup?: (trx: Transaction) => Promise<void>,\n    level: IsolationLevel = IsolationLevel.REPEATABLE_READ,\n  ) {\n    return this.api.extend<DatabaseFixtures<Transaction>>({\n      // This fixture automatically provides a transaction to each test\n      trx: async ({}, use) => {\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 createConnection();\n        try {\n          await this.transact(conn, level, 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    });\n  }\n}\n\nexport type DatabaseConnectionFn<Conn> = () => Conn | Promise<Conn>;\nexport type DatabaseConnection<Conn> = DatabaseConnectionFn<Conn>;\n"],"mappings":";;;;;;;;AAsBA,IAAY,4DAAL;;;;;AAKL;;;;;AAKA;;;;;AAKA;;;;;AAKA;;AACD;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6BD,IAAsB,oCAAtB,MAA4E;;;;;;CAsB1E,YAA6BA,KAAc;EAAd;CAAgB;;;;;;;;;;;;;;;;;;;;;;;CAwB7C,0BACEC,kBACAC,OACAC,QAAwB,eAAe,iBACvC;AACA,SAAO,KAAK,IAAI,OAAsC,EAEpD,KAAK,OAAO,EAAE,EAAE,QAAQ;GAEtB,MAAM,qBAAqB,MAAM;IAC/B,cAAc;AACZ,WAAM,gBAAgB;AACtB,UAAK,OAAO;IACb;GACF;GAED,IAAIC;GACJ,MAAM,OAAO,MAAM,kBAAkB;AACrC,OAAI;AACF,UAAM,KAAK,SAAS,MAAM,OAAO,OAAO,gBAAgB;AACtD,SAAI;AAEF,YAAM,QAAQ,YAAY;AAC1B,YAAM,IAAI,YAAY;KACvB,SAAQ,OAAO;AAEd,kBAAY;KACb;AAGD,WAAM,IAAI;IACX,EAAC;GACH,SAAQ,OAAO;AAEd,UAAM,iBAAiB,cACrB,OAAM;AAIR,QAAI,UACF,OAAM;GAET,UAAS;AACR,UAAM,KAAK,QAAQ,KAAK;GACzB;EACF,EACF,EAAC;CACH;AACF"}

package/dist/{VitestTransactionIsolator-zdyiS_SY.d.mts → VitestTransactionIsolator-CsfJBxcb.d.mts}

@@ -118,4 +118,5 @@ declare abstract class VitestPostgresTransactionIsolator<TConn, Transaction> {
 type DatabaseConnectionFn<Conn> = () => Conn | Promise<Conn>;
 type DatabaseConnection<Conn> = DatabaseConnectionFn<Conn>;
 //#endregion
-export { DatabaseConnection, DatabaseConnectionFn, DatabaseFixtures, IsolationLevel, VitestPostgresTransactionIsolator };
+export { DatabaseConnection, DatabaseConnectionFn, DatabaseFixtures, IsolationLevel, VitestPostgresTransactionIsolator };
+//# sourceMappingURL=VitestTransactionIsolator-CsfJBxcb.d.mts.map

package/dist/VitestTransactionIsolator-CskiiJbW.mjs

@@ -117,4 +117,5 @@ var VitestPostgresTransactionIsolator = class {
 };
 
 //#endregion
-export { IsolationLevel, VitestPostgresTransactionIsolator };
+export { IsolationLevel, VitestPostgresTransactionIsolator };
+//# sourceMappingURL=VitestTransactionIsolator-CskiiJbW.mjs.map

package/dist/VitestTransactionIsolator-CskiiJbW.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"VitestTransactionIsolator-CskiiJbW.mjs","names":["api: TestAPI","createConnection: DatabaseConnection<TConn>","setup?: (trx: Transaction) => Promise<void>","level: IsolationLevel","testError: Error | undefined"],"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 */\nexport interface DatabaseFixtures<Transaction> {\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 * 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 conn - The database connection to use\n   * @param setup - Optional setup function to run within the transaction before each test\n   * @param level - The transaction isolation level (defaults to REPEATABLE_READ)\n   * @returns A wrapped test API with transaction support\n   *\n   * @example\n   * ```typescript\n   * const isolatedTest = isolator.wrapVitestWithTransaction(db, async (trx) => {\n   *   // Optional setup: create common test data\n   *   await trx.insert('settings', { key: 'test', value: 'true' });\n   * });\n   *\n   * isolatedTest('test with transaction', async ({ trx }) => {\n   *   const user = await trx.insert('users', { name: 'Test' });\n   *   expect(user).toBeDefined();\n   * });\n   * ```\n   */\n  wrapVitestWithTransaction(\n    createConnection: DatabaseConnection<TConn>,\n    setup?: (trx: Transaction) => Promise<void>,\n    level: IsolationLevel = IsolationLevel.REPEATABLE_READ,\n  ) {\n    return this.api.extend<DatabaseFixtures<Transaction>>({\n      // This fixture automatically provides a transaction to each test\n      trx: async ({}, use) => {\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 createConnection();\n        try {\n          await this.transact(conn, level, 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    });\n  }\n}\n\nexport type DatabaseConnectionFn<Conn> = () => Conn | Promise<Conn>;\nexport type DatabaseConnection<Conn> = DatabaseConnectionFn<Conn>;\n"],"mappings":";;;;;;;AAsBA,IAAY,4DAAL;;;;;AAKL;;;;;AAKA;;;;;AAKA;;;;;AAKA;;AACD;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6BD,IAAsB,oCAAtB,MAA4E;;;;;;CAsB1E,YAA6BA,KAAc;EAAd;CAAgB;;;;;;;;;;;;;;;;;;;;;;;CAwB7C,0BACEC,kBACAC,OACAC,QAAwB,eAAe,iBACvC;AACA,SAAO,KAAK,IAAI,OAAsC,EAEpD,KAAK,OAAO,EAAE,EAAE,QAAQ;GAEtB,MAAM,qBAAqB,MAAM;IAC/B,cAAc;AACZ,WAAM,gBAAgB;AACtB,UAAK,OAAO;IACb;GACF;GAED,IAAIC;GACJ,MAAM,OAAO,MAAM,kBAAkB;AACrC,OAAI;AACF,UAAM,KAAK,SAAS,MAAM,OAAO,OAAO,gBAAgB;AACtD,SAAI;AAEF,YAAM,QAAQ,YAAY;AAC1B,YAAM,IAAI,YAAY;KACvB,SAAQ,OAAO;AAEd,kBAAY;KACb;AAGD,WAAM,IAAI;IACX,EAAC;GACH,SAAQ,OAAO;AAEd,UAAM,iBAAiB,cACrB,OAAM;AAIR,QAAI,UACF,OAAM;GAET,UAAS;AACR,UAAM,KAAK,QAAQ,KAAK;GACzB;EACF,EACF,EAAC;CACH;AACF"}

package/dist/VitestTransactionIsolator-DdLNODZg.d.cts

@@ -118,4 +118,5 @@ declare abstract class VitestPostgresTransactionIsolator<TConn, Transaction> {
 type DatabaseConnectionFn<Conn> = () => Conn | Promise<Conn>;
 type DatabaseConnection<Conn> = DatabaseConnectionFn<Conn>;
 //#endregion
-export { DatabaseConnection, DatabaseConnectionFn, DatabaseFixtures, IsolationLevel, VitestPostgresTransactionIsolator };
+export { DatabaseConnection, DatabaseConnectionFn, DatabaseFixtures, IsolationLevel, VitestPostgresTransactionIsolator };
+//# sourceMappingURL=VitestTransactionIsolator-DdLNODZg.d.cts.map

package/dist/VitestTransactionIsolator.d.mts

@@ -1,2 +1,2 @@
-import { DatabaseConnection, DatabaseConnectionFn, DatabaseFixtures, IsolationLevel, VitestPostgresTransactionIsolator } from "./VitestTransactionIsolator-zdyiS_SY.mjs";
+import { DatabaseConnection, DatabaseConnectionFn, DatabaseFixtures, IsolationLevel, VitestPostgresTransactionIsolator } from "./VitestTransactionIsolator-CsfJBxcb.mjs";
 export { DatabaseConnection, DatabaseConnectionFn, DatabaseFixtures, IsolationLevel, VitestPostgresTransactionIsolator };

package/dist/aws.cjs

@@ -0,0 +1,126 @@
+const require_chunk = require('./chunk-CUT6urMc.cjs');
+const vitest = require_chunk.__toESM(require("vitest"));
+
+//#region src/aws.ts
+/**
+* Shared test utilities for AWS Lambda adapter testing
+*/
+/**
+* Creates a mock AWS Lambda Context for testing
+*/
+function createMockContext() {
+	return {
+		awsRequestId: "test-request-id",
+		callbackWaitsForEmptyEventLoop: false,
+		functionName: "test-function",
+		functionVersion: "1",
+		invokedFunctionArn: "arn:aws:lambda:us-east-1:123456789012:function:test-function",
+		memoryLimitInMB: "128",
+		logGroupName: "/aws/lambda/test-function",
+		logStreamName: "2024/01/01/[$LATEST]abcdef123456",
+		getRemainingTimeInMillis: () => 5e3,
+		done: vitest.vi.fn(),
+		fail: vitest.vi.fn(),
+		succeed: vitest.vi.fn()
+	};
+}
+/**
+* Creates a mock AWS API Gateway V1 (REST API) event for testing
+*/
+function createMockV1Event(overrides = {}) {
+	return {
+		body: null,
+		headers: {
+			"content-type": "application/json",
+			"user-agent": "test-agent",
+			host: "test.example.com"
+		},
+		multiValueHeaders: {},
+		httpMethod: "GET",
+		isBase64Encoded: false,
+		path: "/test",
+		pathParameters: null,
+		queryStringParameters: null,
+		multiValueQueryStringParameters: null,
+		stageVariables: null,
+		requestContext: {
+			accountId: "123456789012",
+			apiId: "api-id",
+			authorizer: null,
+			protocol: "HTTP/1.1",
+			httpMethod: "GET",
+			path: "/test",
+			stage: "test",
+			requestId: "request-id",
+			requestTimeEpoch: 17040672e5,
+			resourceId: "resource-id",
+			resourcePath: "/test",
+			identity: {
+				accessKey: null,
+				accountId: null,
+				apiKey: null,
+				apiKeyId: null,
+				caller: null,
+				cognitoAuthenticationProvider: null,
+				cognitoAuthenticationType: null,
+				cognitoIdentityId: null,
+				cognitoIdentityPoolId: null,
+				principalOrgId: null,
+				sourceIp: "127.0.0.1",
+				user: null,
+				userAgent: "test-agent",
+				userArn: null,
+				clientCert: null
+			}
+		},
+		resource: "/test",
+		...overrides
+	};
+}
+/**
+* Creates a mock AWS API Gateway V2 (HTTP API) event for testing
+*/
+function createMockV2Event(overrides = {}) {
+	return {
+		version: "2.0",
+		routeKey: "GET /test",
+		rawPath: "/test",
+		rawQueryString: "",
+		headers: {
+			"content-type": "application/json",
+			"user-agent": "test-agent",
+			host: "test.example.com"
+		},
+		requestContext: {
+			accountId: "123456789012",
+			apiId: "api-id",
+			domainName: "test.example.com",
+			domainPrefix: "api",
+			requestId: "request-id",
+			routeKey: "GET /test",
+			stage: "test",
+			time: "01/Jan/2024:00:00:00 +0000",
+			timeEpoch: 17040672e5,
+			http: {
+				method: "GET",
+				path: "/test",
+				protocol: "HTTP/1.1",
+				sourceIp: "127.0.0.1",
+				userAgent: "test-agent"
+			}
+		},
+		body: void 0,
+		pathParameters: void 0,
+		isBase64Encoded: false,
+		stageVariables: void 0,
+		queryStringParameters: void 0,
+		cookies: void 0,
+		...overrides
+	};
+}
+
+//#endregion
+exports.createMockContext = createMockContext;
+exports.createMockV1Event = createMockV1Event;
+exports.createMockV2Event = createMockV2Event;
+//# sourceMappingURL=aws.cjs.map

package/dist/aws.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"aws.cjs","names":["overrides: Partial<APIGatewayProxyEvent>","overrides: Partial<APIGatewayProxyEventV2>"],"sources":["../src/aws.ts"],"sourcesContent":["import type {\n  APIGatewayProxyEvent,\n  APIGatewayProxyEventV2,\n  Context,\n} from 'aws-lambda';\nimport { vi } from 'vitest';\n\n/**\n * Shared test utilities for AWS Lambda adapter testing\n */\n\n/**\n * Creates a mock AWS Lambda Context for testing\n */\nexport function createMockContext(): Context {\n  return {\n    awsRequestId: 'test-request-id',\n    callbackWaitsForEmptyEventLoop: false,\n    functionName: 'test-function',\n    functionVersion: '1',\n    invokedFunctionArn:\n      'arn:aws:lambda:us-east-1:123456789012:function:test-function',\n    memoryLimitInMB: '128',\n    logGroupName: '/aws/lambda/test-function',\n    logStreamName: '2024/01/01/[$LATEST]abcdef123456',\n    getRemainingTimeInMillis: () => 5000,\n    done: vi.fn(),\n    fail: vi.fn(),\n    succeed: vi.fn(),\n  };\n}\n\n/**\n * Creates a mock AWS API Gateway V1 (REST API) event for testing\n */\nexport function createMockV1Event(\n  overrides: Partial<APIGatewayProxyEvent> = {},\n): APIGatewayProxyEvent {\n  return {\n    body: null,\n    headers: {\n      'content-type': 'application/json',\n      'user-agent': 'test-agent',\n      host: 'test.example.com',\n    },\n    multiValueHeaders: {},\n    httpMethod: 'GET',\n    isBase64Encoded: false,\n    path: '/test',\n    pathParameters: null,\n    queryStringParameters: null,\n    multiValueQueryStringParameters: null,\n    stageVariables: null,\n    requestContext: {\n      accountId: '123456789012',\n      apiId: 'api-id',\n      authorizer: null,\n      protocol: 'HTTP/1.1',\n      httpMethod: 'GET',\n      path: '/test',\n      stage: 'test',\n      requestId: 'request-id',\n      requestTimeEpoch: 1704067200000,\n      resourceId: 'resource-id',\n      resourcePath: '/test',\n      identity: {\n        accessKey: null,\n        accountId: null,\n        apiKey: null,\n        apiKeyId: null,\n        caller: null,\n        cognitoAuthenticationProvider: null,\n        cognitoAuthenticationType: null,\n        cognitoIdentityId: null,\n        cognitoIdentityPoolId: null,\n        principalOrgId: null,\n        sourceIp: '127.0.0.1',\n        user: null,\n        userAgent: 'test-agent',\n        userArn: null,\n        clientCert: null,\n      },\n    },\n    resource: '/test',\n    ...overrides,\n  };\n}\n\n/**\n * Creates a mock AWS API Gateway V2 (HTTP API) event for testing\n */\nexport function createMockV2Event(\n  overrides: Partial<APIGatewayProxyEventV2> = {},\n): APIGatewayProxyEventV2 {\n  return {\n    version: '2.0',\n    routeKey: 'GET /test',\n    rawPath: '/test',\n    rawQueryString: '',\n    headers: {\n      'content-type': 'application/json',\n      'user-agent': 'test-agent',\n      host: 'test.example.com',\n    },\n    requestContext: {\n      accountId: '123456789012',\n      apiId: 'api-id',\n      domainName: 'test.example.com',\n      domainPrefix: 'api',\n      requestId: 'request-id',\n      routeKey: 'GET /test',\n      stage: 'test',\n      time: '01/Jan/2024:00:00:00 +0000',\n      timeEpoch: 1704067200000,\n      http: {\n        method: 'GET',\n        path: '/test',\n        protocol: 'HTTP/1.1',\n        sourceIp: '127.0.0.1',\n        userAgent: 'test-agent',\n      },\n    },\n    body: undefined,\n    pathParameters: undefined,\n    isBase64Encoded: false,\n    stageVariables: undefined,\n    queryStringParameters: undefined,\n    cookies: undefined,\n    ...overrides,\n  };\n}\n"],"mappings":";;;;;;;;;;AAcA,SAAgB,oBAA6B;AAC3C,QAAO;EACL,cAAc;EACd,gCAAgC;EAChC,cAAc;EACd,iBAAiB;EACjB,oBACE;EACF,iBAAiB;EACjB,cAAc;EACd,eAAe;EACf,0BAA0B,MAAM;EAChC,MAAM,UAAG,IAAI;EACb,MAAM,UAAG,IAAI;EACb,SAAS,UAAG,IAAI;CACjB;AACF;;;;AAKD,SAAgB,kBACdA,YAA2C,CAAE,GACvB;AACtB,QAAO;EACL,MAAM;EACN,SAAS;GACP,gBAAgB;GAChB,cAAc;GACd,MAAM;EACP;EACD,mBAAmB,CAAE;EACrB,YAAY;EACZ,iBAAiB;EACjB,MAAM;EACN,gBAAgB;EAChB,uBAAuB;EACvB,iCAAiC;EACjC,gBAAgB;EAChB,gBAAgB;GACd,WAAW;GACX,OAAO;GACP,YAAY;GACZ,UAAU;GACV,YAAY;GACZ,MAAM;GACN,OAAO;GACP,WAAW;GACX,kBAAkB;GAClB,YAAY;GACZ,cAAc;GACd,UAAU;IACR,WAAW;IACX,WAAW;IACX,QAAQ;IACR,UAAU;IACV,QAAQ;IACR,+BAA+B;IAC/B,2BAA2B;IAC3B,mBAAmB;IACnB,uBAAuB;IACvB,gBAAgB;IAChB,UAAU;IACV,MAAM;IACN,WAAW;IACX,SAAS;IACT,YAAY;GACb;EACF;EACD,UAAU;EACV,GAAG;CACJ;AACF;;;;AAKD,SAAgB,kBACdC,YAA6C,CAAE,GACvB;AACxB,QAAO;EACL,SAAS;EACT,UAAU;EACV,SAAS;EACT,gBAAgB;EAChB,SAAS;GACP,gBAAgB;GAChB,cAAc;GACd,MAAM;EACP;EACD,gBAAgB;GACd,WAAW;GACX,OAAO;GACP,YAAY;GACZ,cAAc;GACd,WAAW;GACX,UAAU;GACV,OAAO;GACP,MAAM;GACN,WAAW;GACX,MAAM;IACJ,QAAQ;IACR,MAAM;IACN,UAAU;IACV,UAAU;IACV,WAAW;GACZ;EACF;EACD;EACA;EACA,iBAAiB;EACjB;EACA;EACA;EACA,GAAG;CACJ;AACF"}

package/dist/aws.d.cts

@@ -0,0 +1,22 @@
+import { APIGatewayProxyEvent, APIGatewayProxyEventV2, Context } from "aws-lambda";
+
+//#region src/aws.d.ts
+
+/**
+ * Shared test utilities for AWS Lambda adapter testing
+ */
+/**
+ * Creates a mock AWS Lambda Context for testing
+ */
+declare function createMockContext(): Context;
+/**
+ * Creates a mock AWS API Gateway V1 (REST API) event for testing
+ */
+declare function createMockV1Event(overrides?: Partial<APIGatewayProxyEvent>): APIGatewayProxyEvent;
+/**
+ * Creates a mock AWS API Gateway V2 (HTTP API) event for testing
+ */
+declare function createMockV2Event(overrides?: Partial<APIGatewayProxyEventV2>): APIGatewayProxyEventV2;
+//#endregion
+export { createMockContext, createMockV1Event, createMockV2Event };
+//# sourceMappingURL=aws.d.cts.map

package/dist/aws.d.mts

@@ -0,0 +1,22 @@
+import { APIGatewayProxyEvent, APIGatewayProxyEventV2, Context } from "aws-lambda";
+
+//#region src/aws.d.ts
+
+/**
+ * Shared test utilities for AWS Lambda adapter testing
+ */
+/**
+ * Creates a mock AWS Lambda Context for testing
+ */
+declare function createMockContext(): Context;
+/**
+ * Creates a mock AWS API Gateway V1 (REST API) event for testing
+ */
+declare function createMockV1Event(overrides?: Partial<APIGatewayProxyEvent>): APIGatewayProxyEvent;
+/**
+ * Creates a mock AWS API Gateway V2 (HTTP API) event for testing
+ */
+declare function createMockV2Event(overrides?: Partial<APIGatewayProxyEventV2>): APIGatewayProxyEventV2;
+//#endregion
+export { createMockContext, createMockV1Event, createMockV2Event };
+//# sourceMappingURL=aws.d.mts.map

package/dist/aws.mjs

@@ -0,0 +1,123 @@
+import { vi } from "vitest";
+
+//#region src/aws.ts
+/**
+* Shared test utilities for AWS Lambda adapter testing
+*/
+/**
+* Creates a mock AWS Lambda Context for testing
+*/
+function createMockContext() {
+	return {
+		awsRequestId: "test-request-id",
+		callbackWaitsForEmptyEventLoop: false,
+		functionName: "test-function",
+		functionVersion: "1",
+		invokedFunctionArn: "arn:aws:lambda:us-east-1:123456789012:function:test-function",
+		memoryLimitInMB: "128",
+		logGroupName: "/aws/lambda/test-function",
+		logStreamName: "2024/01/01/[$LATEST]abcdef123456",
+		getRemainingTimeInMillis: () => 5e3,
+		done: vi.fn(),
+		fail: vi.fn(),
+		succeed: vi.fn()
+	};
+}
+/**
+* Creates a mock AWS API Gateway V1 (REST API) event for testing
+*/
+function createMockV1Event(overrides = {}) {
+	return {
+		body: null,
+		headers: {
+			"content-type": "application/json",
+			"user-agent": "test-agent",
+			host: "test.example.com"
+		},
+		multiValueHeaders: {},
+		httpMethod: "GET",
+		isBase64Encoded: false,
+		path: "/test",
+		pathParameters: null,
+		queryStringParameters: null,
+		multiValueQueryStringParameters: null,
+		stageVariables: null,
+		requestContext: {
+			accountId: "123456789012",
+			apiId: "api-id",
+			authorizer: null,
+			protocol: "HTTP/1.1",
+			httpMethod: "GET",
+			path: "/test",
+			stage: "test",
+			requestId: "request-id",
+			requestTimeEpoch: 17040672e5,
+			resourceId: "resource-id",
+			resourcePath: "/test",
+			identity: {
+				accessKey: null,
+				accountId: null,
+				apiKey: null,
+				apiKeyId: null,
+				caller: null,
+				cognitoAuthenticationProvider: null,
+				cognitoAuthenticationType: null,
+				cognitoIdentityId: null,
+				cognitoIdentityPoolId: null,
+				principalOrgId: null,
+				sourceIp: "127.0.0.1",
+				user: null,
+				userAgent: "test-agent",
+				userArn: null,
+				clientCert: null
+			}
+		},
+		resource: "/test",
+		...overrides
+	};
+}
+/**
+* Creates a mock AWS API Gateway V2 (HTTP API) event for testing
+*/
+function createMockV2Event(overrides = {}) {
+	return {
+		version: "2.0",
+		routeKey: "GET /test",
+		rawPath: "/test",
+		rawQueryString: "",
+		headers: {
+			"content-type": "application/json",
+			"user-agent": "test-agent",
+			host: "test.example.com"
+		},
+		requestContext: {
+			accountId: "123456789012",
+			apiId: "api-id",
+			domainName: "test.example.com",
+			domainPrefix: "api",
+			requestId: "request-id",
+			routeKey: "GET /test",
+			stage: "test",
+			time: "01/Jan/2024:00:00:00 +0000",
+			timeEpoch: 17040672e5,
+			http: {
+				method: "GET",
+				path: "/test",
+				protocol: "HTTP/1.1",
+				sourceIp: "127.0.0.1",
+				userAgent: "test-agent"
+			}
+		},
+		body: void 0,
+		pathParameters: void 0,
+		isBase64Encoded: false,
+		stageVariables: void 0,
+		queryStringParameters: void 0,
+		cookies: void 0,
+		...overrides
+	};
+}
+
+//#endregion
+export { createMockContext, createMockV1Event, createMockV2Event };
+//# sourceMappingURL=aws.mjs.map

package/dist/aws.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"aws.mjs","names":["overrides: Partial<APIGatewayProxyEvent>","overrides: Partial<APIGatewayProxyEventV2>"],"sources":["../src/aws.ts"],"sourcesContent":["import type {\n  APIGatewayProxyEvent,\n  APIGatewayProxyEventV2,\n  Context,\n} from 'aws-lambda';\nimport { vi } from 'vitest';\n\n/**\n * Shared test utilities for AWS Lambda adapter testing\n */\n\n/**\n * Creates a mock AWS Lambda Context for testing\n */\nexport function createMockContext(): Context {\n  return {\n    awsRequestId: 'test-request-id',\n    callbackWaitsForEmptyEventLoop: false,\n    functionName: 'test-function',\n    functionVersion: '1',\n    invokedFunctionArn:\n      'arn:aws:lambda:us-east-1:123456789012:function:test-function',\n    memoryLimitInMB: '128',\n    logGroupName: '/aws/lambda/test-function',\n    logStreamName: '2024/01/01/[$LATEST]abcdef123456',\n    getRemainingTimeInMillis: () => 5000,\n    done: vi.fn(),\n    fail: vi.fn(),\n    succeed: vi.fn(),\n  };\n}\n\n/**\n * Creates a mock AWS API Gateway V1 (REST API) event for testing\n */\nexport function createMockV1Event(\n  overrides: Partial<APIGatewayProxyEvent> = {},\n): APIGatewayProxyEvent {\n  return {\n    body: null,\n    headers: {\n      'content-type': 'application/json',\n      'user-agent': 'test-agent',\n      host: 'test.example.com',\n    },\n    multiValueHeaders: {},\n    httpMethod: 'GET',\n    isBase64Encoded: false,\n    path: '/test',\n    pathParameters: null,\n    queryStringParameters: null,\n    multiValueQueryStringParameters: null,\n    stageVariables: null,\n    requestContext: {\n      accountId: '123456789012',\n      apiId: 'api-id',\n      authorizer: null,\n      protocol: 'HTTP/1.1',\n      httpMethod: 'GET',\n      path: '/test',\n      stage: 'test',\n      requestId: 'request-id',\n      requestTimeEpoch: 1704067200000,\n      resourceId: 'resource-id',\n      resourcePath: '/test',\n      identity: {\n        accessKey: null,\n        accountId: null,\n        apiKey: null,\n        apiKeyId: null,\n        caller: null,\n        cognitoAuthenticationProvider: null,\n        cognitoAuthenticationType: null,\n        cognitoIdentityId: null,\n        cognitoIdentityPoolId: null,\n        principalOrgId: null,\n        sourceIp: '127.0.0.1',\n        user: null,\n        userAgent: 'test-agent',\n        userArn: null,\n        clientCert: null,\n      },\n    },\n    resource: '/test',\n    ...overrides,\n  };\n}\n\n/**\n * Creates a mock AWS API Gateway V2 (HTTP API) event for testing\n */\nexport function createMockV2Event(\n  overrides: Partial<APIGatewayProxyEventV2> = {},\n): APIGatewayProxyEventV2 {\n  return {\n    version: '2.0',\n    routeKey: 'GET /test',\n    rawPath: '/test',\n    rawQueryString: '',\n    headers: {\n      'content-type': 'application/json',\n      'user-agent': 'test-agent',\n      host: 'test.example.com',\n    },\n    requestContext: {\n      accountId: '123456789012',\n      apiId: 'api-id',\n      domainName: 'test.example.com',\n      domainPrefix: 'api',\n      requestId: 'request-id',\n      routeKey: 'GET /test',\n      stage: 'test',\n      time: '01/Jan/2024:00:00:00 +0000',\n      timeEpoch: 1704067200000,\n      http: {\n        method: 'GET',\n        path: '/test',\n        protocol: 'HTTP/1.1',\n        sourceIp: '127.0.0.1',\n        userAgent: 'test-agent',\n      },\n    },\n    body: undefined,\n    pathParameters: undefined,\n    isBase64Encoded: false,\n    stageVariables: undefined,\n    queryStringParameters: undefined,\n    cookies: undefined,\n    ...overrides,\n  };\n}\n"],"mappings":";;;;;;;;;AAcA,SAAgB,oBAA6B;AAC3C,QAAO;EACL,cAAc;EACd,gCAAgC;EAChC,cAAc;EACd,iBAAiB;EACjB,oBACE;EACF,iBAAiB;EACjB,cAAc;EACd,eAAe;EACf,0BAA0B,MAAM;EAChC,MAAM,GAAG,IAAI;EACb,MAAM,GAAG,IAAI;EACb,SAAS,GAAG,IAAI;CACjB;AACF;;;;AAKD,SAAgB,kBACdA,YAA2C,CAAE,GACvB;AACtB,QAAO;EACL,MAAM;EACN,SAAS;GACP,gBAAgB;GAChB,cAAc;GACd,MAAM;EACP;EACD,mBAAmB,CAAE;EACrB,YAAY;EACZ,iBAAiB;EACjB,MAAM;EACN,gBAAgB;EAChB,uBAAuB;EACvB,iCAAiC;EACjC,gBAAgB;EAChB,gBAAgB;GACd,WAAW;GACX,OAAO;GACP,YAAY;GACZ,UAAU;GACV,YAAY;GACZ,MAAM;GACN,OAAO;GACP,WAAW;GACX,kBAAkB;GAClB,YAAY;GACZ,cAAc;GACd,UAAU;IACR,WAAW;IACX,WAAW;IACX,QAAQ;IACR,UAAU;IACV,QAAQ;IACR,+BAA+B;IAC/B,2BAA2B;IAC3B,mBAAmB;IACnB,uBAAuB;IACvB,gBAAgB;IAChB,UAAU;IACV,MAAM;IACN,WAAW;IACX,SAAS;IACT,YAAY;GACb;EACF;EACD,UAAU;EACV,GAAG;CACJ;AACF;;;;AAKD,SAAgB,kBACdC,YAA6C,CAAE,GACvB;AACxB,QAAO;EACL,SAAS;EACT,UAAU;EACV,SAAS;EACT,gBAAgB;EAChB,SAAS;GACP,gBAAgB;GAChB,cAAc;GACd,MAAM;EACP;EACD,gBAAgB;GACd,WAAW;GACX,OAAO;GACP,YAAY;GACZ,cAAc;GACd,WAAW;GACX,UAAU;GACV,OAAO;GACP,MAAM;GACN,WAAW;GACX,MAAM;IACJ,QAAQ;IACR,MAAM;IACN,UAAU;IACV,UAAU;IACV,WAAW;GACZ;EACF;EACD;EACA;EACA,iBAAiB;EACjB;EACA;EACA;EACA,GAAG;CACJ;AACF"}

package/dist/directory-B-Ozljzk.mjs

@@ -0,0 +1,22 @@
+import { it } from "vitest";
+import crypto from "node:crypto";
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+
+//#region src/os/directory.ts
+const itWithDir = it.extend({ dir: async ({}, use) => {
+	const tempDir = os.tmpdir();
+	const directoryName = crypto.randomUUID().replace(/-/g, "").toUpperCase();
+	const dir = path.join(tempDir, directoryName);
+	await fs.mkdir(dir, { recursive: true });
+	await use(dir);
+	await fs.rm(dir, {
+		recursive: true,
+		force: true
+	});
+} });
+
+//#endregion
+export { itWithDir };
+//# sourceMappingURL=directory-B-Ozljzk.mjs.map

package/dist/directory-B-Ozljzk.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"directory-B-Ozljzk.mjs","names":[],"sources":["../src/os/directory.ts"],"sourcesContent":["import crypto from 'node:crypto';\nimport fs from 'node:fs/promises';\nimport os from 'node:os';\nimport path from 'node:path';\nimport { it } from 'vitest';\n\nexport const itWithDir = it.extend<DirectoryFixtures>({\n  // This fixture automatically provides a transaction to each test\n  dir: async ({}, use) => {\n    const tempDir = os.tmpdir();\n    const directoryName = crypto.randomUUID().replace(/-/g, '').toUpperCase();\n    const dir = path.join(tempDir, directoryName);\n    await fs.mkdir(dir, { recursive: true });\n    await use(dir);\n    await fs.rm(dir, { recursive: true, force: true });\n  },\n});\n\nexport interface DirectoryFixtures {\n  dir: string;\n}\n"],"mappings":";;;;;;;AAMA,MAAa,YAAY,GAAG,OAA0B,EAEpD,KAAK,OAAO,EAAE,EAAE,QAAQ;CACtB,MAAM,UAAU,GAAG,QAAQ;CAC3B,MAAM,gBAAgB,OAAO,YAAY,CAAC,QAAQ,MAAM,GAAG,CAAC,aAAa;CACzE,MAAM,MAAM,KAAK,KAAK,SAAS,cAAc;AAC7C,OAAM,GAAG,MAAM,KAAK,EAAE,WAAW,KAAM,EAAC;AACxC,OAAM,IAAI,IAAI;AACd,OAAM,GAAG,GAAG,KAAK;EAAE,WAAW;EAAM,OAAO;CAAM,EAAC;AACnD,EACF,EAAC"}

package/dist/directory-B4oYx02C.d.mts

@@ -0,0 +1,12 @@
+import * as vitest0 from "vitest";
+
+//#region src/os/directory.d.ts
+declare const itWithDir: vitest0.TestAPI<{
+  dir: string;
+}>;
+interface DirectoryFixtures {
+  dir: string;
+}
+//#endregion
+export { DirectoryFixtures, itWithDir };
+//# sourceMappingURL=directory-B4oYx02C.d.mts.map