@geekmidas/testkit 0.0.15 → 0.0.16

package/dist/objection.cjs

@@ -5,10 +5,88 @@ require('./PostgresMigrator-DFcNdCvD.cjs');
 const require_PostgresObjectionMigrator = require('./PostgresObjectionMigrator-BG6ymgnt.cjs');
 const require_VitestTransactionIsolator = require('./VitestTransactionIsolator-BQ5FpLtC.cjs');
 const require_VitestObjectionTransactionIsolator = require('./VitestObjectionTransactionIsolator-DzeF4UAq.cjs');
-const require_objection = require('./objection-BpLv_ZfC.cjs');
 
+//#region src/objection.ts
+/**
+* Creates a wrapped Vitest test API with automatic transaction rollback for Objection.js.
+* Each test runs in an isolated database transaction that is rolled back after completion.
+* This ensures tests don't affect each other's data and run faster than truncating tables.
+*
+* @param api - The Vitest test API (usually `test` from vitest)
+* @param conn - The Knex database connection instance
+* @param setup - Optional setup function to run before each test in the transaction
+* @param level - Transaction isolation level (defaults to REPEATABLE_READ)
+* @returns A wrapped test API that provides transaction isolation
+*
+* @example
+* ```typescript
+* import { test } from 'vitest';
+* import { wrapVitestObjectionTransaction } from '@geekmidas/testkit/objection';
+* import { knex } from './database';
+* import { User, Post } from './models';
+*
+* // Create isolated test with automatic rollback
+* const isolatedTest = wrapVitestObjectionTransaction(test, knex);
+*
+* // Use in tests - each test gets its own transaction
+* isolatedTest('should create user', async ({ trx }) => {
+*   const user = await User.query(trx)
+*     .insert({ name: 'Test User', email: 'test@example.com' });
+*
+*   expect(user).toBeDefined();
+*   // User is automatically rolled back after test
+* });
+*
+* // With setup function for common test data
+* const testWithSetup = wrapVitestObjectionTransaction(
+*   test,
+*   knex,
+*   async (trx) => {
+*     // Create common test data
+*     await knex('settings')
+*       .transacting(trx)
+*       .insert({ key: 'test_mode', value: 'true' });
+*   }
+* );
+*
+* testWithSetup('should have test settings', async ({ trx }) => {
+*   const setting = await knex('settings')
+*     .transacting(trx)
+*     .where('key', 'test_mode')
+*     .first();
+*
+*   expect(setting?.value).toBe('true');
+* });
+*
+* // Example with factory and transaction
+* const isolatedTest = wrapVitestObjectionTransaction(test, knex);
+* const factory = new ObjectionFactory(builders, seeds, knex);
+*
+* isolatedTest('creates related data', async ({ trx }) => {
+*   // Factory can use the transaction
+*   const user = await User.query(trx).insert({ name: 'Author' });
+*   const posts = await Post.query(trx).insert([
+*     { title: 'Post 1', userId: user.id },
+*     { title: 'Post 2', userId: user.id }
+*   ]);
+*
+*   const userWithPosts = await User.query(trx)
+*     .findById(user.id)
+*     .withGraphFetched('posts');
+*
+*   expect(userWithPosts.posts).toHaveLength(2);
+* });
+* ```
+*/
+function wrapVitestObjectionTransaction(api, conn, setup, level = require_VitestTransactionIsolator.IsolationLevel.REPEATABLE_READ) {
+	const wrapper = new require_VitestObjectionTransactionIsolator.VitestObjectionTransactionIsolator(api);
+	return wrapper.wrapVitestWithTransaction(conn, setup, level);
+}
+
+//#endregion
 exports.IsolationLevel = require_VitestTransactionIsolator.IsolationLevel;
 exports.ObjectionFactory = require_ObjectionFactory.ObjectionFactory;
 exports.PostgresObjectionMigrator = require_PostgresObjectionMigrator.PostgresObjectionMigrator;
 exports.VitestObjectionTransactionIsolator = require_VitestObjectionTransactionIsolator.VitestObjectionTransactionIsolator;
-exports.wrapVitestObjectionTransaction = require_objection.wrapVitestObjectionTransaction;
+exports.wrapVitestObjectionTransaction = wrapVitestObjectionTransaction;
+//# sourceMappingURL=objection.cjs.map

package/dist/objection.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"objection.cjs","names":["api: TestAPI","conn: DatabaseConnection<Knex>","setup?: (trx: Knex.Transaction) => Promise<void>","level: IsolationLevel","IsolationLevel","VitestObjectionTransactionIsolator"],"sources":["../src/objection.ts"],"sourcesContent":["import type { Knex } from 'knex';\nimport type { TestAPI } from 'vitest';\nimport { VitestObjectionTransactionIsolator } from './VitestObjectionTransactionIsolator';\nimport {\n  type DatabaseConnection,\n  IsolationLevel,\n} from './VitestTransactionIsolator';\n\n/**\n * Objection.js-specific exports for test utilities.\n * Provides factory implementation for creating test data with Objection.js ORM\n * and transaction isolation for test suites.\n */\n\nexport { ObjectionFactory } from './ObjectionFactory';\nexport { VitestObjectionTransactionIsolator } from './VitestObjectionTransactionIsolator';\nexport { IsolationLevel } from './VitestTransactionIsolator';\nexport { PostgresObjectionMigrator } from './PostgresObjectionMigrator';\n\n/**\n * Creates a wrapped Vitest test API with automatic transaction rollback for Objection.js.\n * Each test runs in an isolated database transaction that is rolled back after completion.\n * This ensures tests don't affect each other's data and run faster than truncating tables.\n *\n * @param api - The Vitest test API (usually `test` from vitest)\n * @param conn - The Knex database connection instance\n * @param setup - Optional setup function to run before each test in the transaction\n * @param level - Transaction isolation level (defaults to REPEATABLE_READ)\n * @returns A wrapped test API that provides transaction isolation\n *\n * @example\n * ```typescript\n * import { test } from 'vitest';\n * import { wrapVitestObjectionTransaction } from '@geekmidas/testkit/objection';\n * import { knex } from './database';\n * import { User, Post } from './models';\n *\n * // Create isolated test with automatic rollback\n * const isolatedTest = wrapVitestObjectionTransaction(test, knex);\n *\n * // Use in tests - each test gets its own transaction\n * isolatedTest('should create user', async ({ trx }) => {\n *   const user = await User.query(trx)\n *     .insert({ name: 'Test User', email: 'test@example.com' });\n *\n *   expect(user).toBeDefined();\n *   // User is automatically rolled back after test\n * });\n *\n * // With setup function for common test data\n * const testWithSetup = wrapVitestObjectionTransaction(\n *   test,\n *   knex,\n *   async (trx) => {\n *     // Create common test data\n *     await knex('settings')\n *       .transacting(trx)\n *       .insert({ key: 'test_mode', value: 'true' });\n *   }\n * );\n *\n * testWithSetup('should have test settings', async ({ trx }) => {\n *   const setting = await knex('settings')\n *     .transacting(trx)\n *     .where('key', 'test_mode')\n *     .first();\n *\n *   expect(setting?.value).toBe('true');\n * });\n *\n * // Example with factory and transaction\n * const isolatedTest = wrapVitestObjectionTransaction(test, knex);\n * const factory = new ObjectionFactory(builders, seeds, knex);\n *\n * isolatedTest('creates related data', async ({ trx }) => {\n *   // Factory can use the transaction\n *   const user = await User.query(trx).insert({ name: 'Author' });\n *   const posts = await Post.query(trx).insert([\n *     { title: 'Post 1', userId: user.id },\n *     { title: 'Post 2', userId: user.id }\n *   ]);\n *\n *   const userWithPosts = await User.query(trx)\n *     .findById(user.id)\n *     .withGraphFetched('posts');\n *\n *   expect(userWithPosts.posts).toHaveLength(2);\n * });\n * ```\n */\nexport function wrapVitestObjectionTransaction(\n  api: TestAPI,\n  conn: DatabaseConnection<Knex>,\n  setup?: (trx: Knex.Transaction) => Promise<void>,\n  level: IsolationLevel = IsolationLevel.REPEATABLE_READ,\n) {\n  const wrapper = new VitestObjectionTransactionIsolator(api);\n\n  return wrapper.wrapVitestWithTransaction(conn, setup, level);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA0FA,SAAgB,+BACdA,KACAC,MACAC,OACAC,QAAwBC,iDAAe,iBACvC;CACA,MAAM,UAAU,IAAIC,8EAAmC;AAEvD,QAAO,QAAQ,0BAA0B,MAAM,OAAO,MAAM;AAC7D"}

package/dist/objection.d.cts

@@ -1,6 +1,6 @@
-import "./faker-BSH1EMtg.cjs";
-import "./Factory-pNV7ZQ7-.cjs";
-import { ObjectionFactory } from "./ObjectionFactory-D3l1VuyX.cjs";
+import "./faker-Cg76aFNO.cjs";
+import "./Factory-BZ8uMoXl.cjs";
+import { ObjectionFactory } from "./ObjectionFactory-C4X78k0B.cjs";
 import "./PostgresMigrator-D5UkK1_K.cjs";
 import { PostgresObjectionMigrator } from "./PostgresObjectionMigrator-CZHHcCOv.cjs";
 import { DatabaseConnection, IsolationLevel } from "./VitestTransactionIsolator-DdLNODZg.cjs";
@@ -85,4 +85,5 @@ declare function wrapVitestObjectionTransaction(api: TestAPI, conn: DatabaseConn
   trx: Knex.Transaction<any, any[]>;
 }>;
 //#endregion
-export { IsolationLevel, ObjectionFactory, PostgresObjectionMigrator, VitestObjectionTransactionIsolator, wrapVitestObjectionTransaction };
+export { IsolationLevel, ObjectionFactory, PostgresObjectionMigrator, VitestObjectionTransactionIsolator, wrapVitestObjectionTransaction };
+//# sourceMappingURL=objection.d.cts.map

package/dist/objection.d.mts

@@ -1,10 +1,10 @@
-import "./faker-C-Iuk_R1.mjs";
-import "./Factory-D7P3bKKb.mjs";
-import { ObjectionFactory } from "./ObjectionFactory-B40NQWSe.mjs";
-import "./PostgresMigrator-BlvuQl7d.mjs";
-import { PostgresObjectionMigrator } from "./PostgresObjectionMigrator-C69n7vzr.mjs";
-import { DatabaseConnection, IsolationLevel } from "./VitestTransactionIsolator-zdyiS_SY.mjs";
-import { VitestObjectionTransactionIsolator } from "./VitestObjectionTransactionIsolator-DIM79dCq.mjs";
+import "./faker-DHh7xs4u.mjs";
+import "./Factory-Cmr3s3-s.mjs";
+import { ObjectionFactory } from "./ObjectionFactory-C-59Hjwj.mjs";
+import "./PostgresMigrator-DQaRxoaY.mjs";
+import { PostgresObjectionMigrator } from "./PostgresObjectionMigrator-D_hCcrQu.mjs";
+import { DatabaseConnection, IsolationLevel } from "./VitestTransactionIsolator-CsfJBxcb.mjs";
+import { VitestObjectionTransactionIsolator } from "./VitestObjectionTransactionIsolator-b973r9O1.mjs";
 import { TestAPI } from "vitest";
 import { Knex } from "knex";
 
@@ -85,4 +85,5 @@ declare function wrapVitestObjectionTransaction(api: TestAPI, conn: DatabaseConn
   trx: Knex.Transaction<any, any[]>;
 }>;
 //#endregion
-export { IsolationLevel, ObjectionFactory, PostgresObjectionMigrator, VitestObjectionTransactionIsolator, wrapVitestObjectionTransaction };
+export { IsolationLevel, ObjectionFactory, PostgresObjectionMigrator, VitestObjectionTransactionIsolator, wrapVitestObjectionTransaction };
+//# sourceMappingURL=objection.d.mts.map

package/dist/objection.mjs

@@ -1,10 +1,88 @@
 import "./Factory-z2m01hMj.mjs";
 import "./faker-BGKYFoCT.mjs";
 import { ObjectionFactory } from "./ObjectionFactory-8hebmnai.mjs";
-import "./PostgresMigrator-DxPC_gGu.mjs";
-import { PostgresObjectionMigrator } from "./PostgresObjectionMigrator-G4h5FLvU.mjs";
+import "./PostgresMigrator-DbuJGAVy.mjs";
+import { PostgresObjectionMigrator } from "./PostgresObjectionMigrator-DPj2pOpX.mjs";
 import { IsolationLevel } from "./VitestTransactionIsolator-CskiiJbW.mjs";
 import { VitestObjectionTransactionIsolator } from "./VitestObjectionTransactionIsolator-BU-jXEhz.mjs";
-import { wrapVitestObjectionTransaction } from "./objection-BI7F86qf.mjs";
 
-export { IsolationLevel, ObjectionFactory, PostgresObjectionMigrator, VitestObjectionTransactionIsolator, wrapVitestObjectionTransaction };
+//#region src/objection.ts
+/**
+* Creates a wrapped Vitest test API with automatic transaction rollback for Objection.js.
+* Each test runs in an isolated database transaction that is rolled back after completion.
+* This ensures tests don't affect each other's data and run faster than truncating tables.
+*
+* @param api - The Vitest test API (usually `test` from vitest)
+* @param conn - The Knex database connection instance
+* @param setup - Optional setup function to run before each test in the transaction
+* @param level - Transaction isolation level (defaults to REPEATABLE_READ)
+* @returns A wrapped test API that provides transaction isolation
+*
+* @example
+* ```typescript
+* import { test } from 'vitest';
+* import { wrapVitestObjectionTransaction } from '@geekmidas/testkit/objection';
+* import { knex } from './database';
+* import { User, Post } from './models';
+*
+* // Create isolated test with automatic rollback
+* const isolatedTest = wrapVitestObjectionTransaction(test, knex);
+*
+* // Use in tests - each test gets its own transaction
+* isolatedTest('should create user', async ({ trx }) => {
+*   const user = await User.query(trx)
+*     .insert({ name: 'Test User', email: 'test@example.com' });
+*
+*   expect(user).toBeDefined();
+*   // User is automatically rolled back after test
+* });
+*
+* // With setup function for common test data
+* const testWithSetup = wrapVitestObjectionTransaction(
+*   test,
+*   knex,
+*   async (trx) => {
+*     // Create common test data
+*     await knex('settings')
+*       .transacting(trx)
+*       .insert({ key: 'test_mode', value: 'true' });
+*   }
+* );
+*
+* testWithSetup('should have test settings', async ({ trx }) => {
+*   const setting = await knex('settings')
+*     .transacting(trx)
+*     .where('key', 'test_mode')
+*     .first();
+*
+*   expect(setting?.value).toBe('true');
+* });
+*
+* // Example with factory and transaction
+* const isolatedTest = wrapVitestObjectionTransaction(test, knex);
+* const factory = new ObjectionFactory(builders, seeds, knex);
+*
+* isolatedTest('creates related data', async ({ trx }) => {
+*   // Factory can use the transaction
+*   const user = await User.query(trx).insert({ name: 'Author' });
+*   const posts = await Post.query(trx).insert([
+*     { title: 'Post 1', userId: user.id },
+*     { title: 'Post 2', userId: user.id }
+*   ]);
+*
+*   const userWithPosts = await User.query(trx)
+*     .findById(user.id)
+*     .withGraphFetched('posts');
+*
+*   expect(userWithPosts.posts).toHaveLength(2);
+* });
+* ```
+*/
+function wrapVitestObjectionTransaction(api, conn, setup, level = IsolationLevel.REPEATABLE_READ) {
+	const wrapper = new VitestObjectionTransactionIsolator(api);
+	return wrapper.wrapVitestWithTransaction(conn, setup, level);
+}
+
+//#endregion
+export { IsolationLevel, ObjectionFactory, PostgresObjectionMigrator, VitestObjectionTransactionIsolator, wrapVitestObjectionTransaction };
+//# sourceMappingURL=objection.mjs.map

package/dist/objection.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"objection.mjs","names":["api: TestAPI","conn: DatabaseConnection<Knex>","setup?: (trx: Knex.Transaction) => Promise<void>","level: IsolationLevel"],"sources":["../src/objection.ts"],"sourcesContent":["import type { Knex } from 'knex';\nimport type { TestAPI } from 'vitest';\nimport { VitestObjectionTransactionIsolator } from './VitestObjectionTransactionIsolator';\nimport {\n  type DatabaseConnection,\n  IsolationLevel,\n} from './VitestTransactionIsolator';\n\n/**\n * Objection.js-specific exports for test utilities.\n * Provides factory implementation for creating test data with Objection.js ORM\n * and transaction isolation for test suites.\n */\n\nexport { ObjectionFactory } from './ObjectionFactory';\nexport { VitestObjectionTransactionIsolator } from './VitestObjectionTransactionIsolator';\nexport { IsolationLevel } from './VitestTransactionIsolator';\nexport { PostgresObjectionMigrator } from './PostgresObjectionMigrator';\n\n/**\n * Creates a wrapped Vitest test API with automatic transaction rollback for Objection.js.\n * Each test runs in an isolated database transaction that is rolled back after completion.\n * This ensures tests don't affect each other's data and run faster than truncating tables.\n *\n * @param api - The Vitest test API (usually `test` from vitest)\n * @param conn - The Knex database connection instance\n * @param setup - Optional setup function to run before each test in the transaction\n * @param level - Transaction isolation level (defaults to REPEATABLE_READ)\n * @returns A wrapped test API that provides transaction isolation\n *\n * @example\n * ```typescript\n * import { test } from 'vitest';\n * import { wrapVitestObjectionTransaction } from '@geekmidas/testkit/objection';\n * import { knex } from './database';\n * import { User, Post } from './models';\n *\n * // Create isolated test with automatic rollback\n * const isolatedTest = wrapVitestObjectionTransaction(test, knex);\n *\n * // Use in tests - each test gets its own transaction\n * isolatedTest('should create user', async ({ trx }) => {\n *   const user = await User.query(trx)\n *     .insert({ name: 'Test User', email: 'test@example.com' });\n *\n *   expect(user).toBeDefined();\n *   // User is automatically rolled back after test\n * });\n *\n * // With setup function for common test data\n * const testWithSetup = wrapVitestObjectionTransaction(\n *   test,\n *   knex,\n *   async (trx) => {\n *     // Create common test data\n *     await knex('settings')\n *       .transacting(trx)\n *       .insert({ key: 'test_mode', value: 'true' });\n *   }\n * );\n *\n * testWithSetup('should have test settings', async ({ trx }) => {\n *   const setting = await knex('settings')\n *     .transacting(trx)\n *     .where('key', 'test_mode')\n *     .first();\n *\n *   expect(setting?.value).toBe('true');\n * });\n *\n * // Example with factory and transaction\n * const isolatedTest = wrapVitestObjectionTransaction(test, knex);\n * const factory = new ObjectionFactory(builders, seeds, knex);\n *\n * isolatedTest('creates related data', async ({ trx }) => {\n *   // Factory can use the transaction\n *   const user = await User.query(trx).insert({ name: 'Author' });\n *   const posts = await Post.query(trx).insert([\n *     { title: 'Post 1', userId: user.id },\n *     { title: 'Post 2', userId: user.id }\n *   ]);\n *\n *   const userWithPosts = await User.query(trx)\n *     .findById(user.id)\n *     .withGraphFetched('posts');\n *\n *   expect(userWithPosts.posts).toHaveLength(2);\n * });\n * ```\n */\nexport function wrapVitestObjectionTransaction(\n  api: TestAPI,\n  conn: DatabaseConnection<Knex>,\n  setup?: (trx: Knex.Transaction) => Promise<void>,\n  level: IsolationLevel = IsolationLevel.REPEATABLE_READ,\n) {\n  const wrapper = new VitestObjectionTransactionIsolator(api);\n\n  return wrapper.wrapVitestWithTransaction(conn, setup, level);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA0FA,SAAgB,+BACdA,KACAC,MACAC,OACAC,QAAwB,eAAe,iBACvC;CACA,MAAM,UAAU,IAAI,mCAAmC;AAEvD,QAAO,QAAQ,0BAA0B,MAAM,OAAO,MAAM;AAC7D"}

package/dist/os/directory.cjs

@@ -0,0 +1,3 @@
+const require_directory = require('../directory-BVC8g7cX.cjs');
+
+exports.itWithDir = require_directory.itWithDir;

package/dist/os/directory.d.cts

@@ -0,0 +1,2 @@
+import { DirectoryFixtures, itWithDir } from "../directory-BUcnztHI.cjs";
+export { DirectoryFixtures, itWithDir };

package/dist/os/directory.d.mts

@@ -0,0 +1,2 @@
+import { DirectoryFixtures, itWithDir } from "../directory-B4oYx02C.mjs";
+export { DirectoryFixtures, itWithDir };

package/dist/os/directory.mjs

@@ -0,0 +1,3 @@
+import { itWithDir } from "../directory-B-Ozljzk.mjs";
+
+export { itWithDir };

package/dist/os/index.cjs

@@ -0,0 +1,3 @@
+const require_directory = require('../directory-BVC8g7cX.cjs');
+
+exports.itWithDir = require_directory.itWithDir;

package/dist/os/index.d.cts

@@ -0,0 +1,2 @@
+import { itWithDir } from "../directory-BUcnztHI.cjs";
+export { itWithDir };

package/dist/os/index.d.mts

@@ -0,0 +1,2 @@
+import { itWithDir } from "../directory-B4oYx02C.mjs";
+export { itWithDir };

package/dist/os/index.mjs

@@ -0,0 +1,3 @@
+import { itWithDir } from "../directory-B-Ozljzk.mjs";
+
+export { itWithDir };

package/dist/timer.cjs

@@ -0,0 +1,9 @@
+
+//#region src/timer.ts
+function waitFor(ms) {
+	return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+//#endregion
+exports.waitFor = waitFor;
+//# sourceMappingURL=timer.cjs.map

package/dist/timer.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"timer.cjs","names":["ms: number"],"sources":["../src/timer.ts"],"sourcesContent":["export function waitFor(ms: number) {\n  return new Promise((resolve) => setTimeout(resolve, ms));\n}\n"],"mappings":";;AAAA,SAAgB,QAAQA,IAAY;AAClC,QAAO,IAAI,QAAQ,CAAC,YAAY,WAAW,SAAS,GAAG;AACxD"}

package/dist/timer.d.cts

@@ -0,0 +1,5 @@
+//#region src/timer.d.ts
+declare function waitFor(ms: number): Promise<unknown>;
+//#endregion
+export { waitFor };
+//# sourceMappingURL=timer.d.cts.map

package/dist/timer.d.mts

@@ -0,0 +1,5 @@
+//#region src/timer.d.ts
+declare function waitFor(ms: number): Promise<unknown>;
+//#endregion
+export { waitFor };
+//# sourceMappingURL=timer.d.mts.map

package/dist/timer.mjs

@@ -0,0 +1,8 @@
+//#region src/timer.ts
+function waitFor(ms) {
+	return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+//#endregion
+export { waitFor };
+//# sourceMappingURL=timer.mjs.map

package/dist/timer.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"timer.mjs","names":["ms: number"],"sources":["../src/timer.ts"],"sourcesContent":["export function waitFor(ms: number) {\n  return new Promise((resolve) => setTimeout(resolve, ms));\n}\n"],"mappings":";AAAA,SAAgB,QAAQA,IAAY;AAClC,QAAO,IAAI,QAAQ,CAAC,YAAY,WAAW,SAAS,GAAG;AACxD"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@geekmidas/testkit",
-  "version": "0.0.15",
+  "version": "0.0.16",
   "private": false,
   "type": "module",
   "exports": {
@@ -9,19 +9,40 @@
       "import": "./dist/objection.mjs",
       "require": "./dist/objection.cjs"
     },
+    "./timer": {
+      "types": "./dist/timer.d.ts",
+      "import": "./dist/timer.mjs",
+      "require": "./dist/timer.cjs"
+    },
     "./kysely": {
       "types": "./dist/kysely.d.ts",
       "import": "./dist/kysely.mjs",
       "require": "./dist/kysely.cjs"
     },
+    "./os": {
+      "types": "./dist/os/index.d.ts",
+      "import": "./dist/os/index.mjs",
+      "require": "./dist/os/index.cjs"
+    },
     "./faker": {
       "types": "./dist/faker.d.ts",
       "import": "./dist/faker.mjs",
       "require": "./dist/faker.cjs"
+    },
+    "./aws": {
+      "types": "./dist/aws.d.ts",
+      "import": "./dist/aws.mjs",
+      "require": "./dist/aws.cjs"
+    },
+    "./logger": {
+      "types": "./dist/logger.d.ts",
+      "import": "./dist/logger.mjs",
+      "require": "./dist/logger.cjs"
     }
   },
   "dependencies": {
-    "@faker-js/faker": "~9.9.0"
+    "@faker-js/faker": "~9.9.0",
+    "@geekmidas/logger": "0.0.1"
   },
   "devDependencies": {
     "@types/pg": "~8.15.4"
@@ -37,6 +58,7 @@
     "objection": "~3.1.5",
     "db-errors": "~0.2.3",
     "vitest": "~3.2.4",
+    "@types/aws-lambda": ">=8.10.92",
     "@geekmidas/envkit": "0.0.7"
   }
 }

package/src/aws.ts

@@ -0,0 +1,131 @@
+import type {
+  APIGatewayProxyEvent,
+  APIGatewayProxyEventV2,
+  Context,
+} from 'aws-lambda';
+import { vi } from 'vitest';
+
+/**
+ * Shared test utilities for AWS Lambda adapter testing
+ */
+
+/**
+ * Creates a mock AWS Lambda Context for testing
+ */
+export function createMockContext(): Context {
+  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: () => 5000,
+    done: vi.fn(),
+    fail: vi.fn(),
+    succeed: vi.fn(),
+  };
+}
+
+/**
+ * Creates a mock AWS API Gateway V1 (REST API) event for testing
+ */
+export function createMockV1Event(
+  overrides: Partial<APIGatewayProxyEvent> = {},
+): APIGatewayProxyEvent {
+  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: 1704067200000,
+      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
+ */
+export function createMockV2Event(
+  overrides: Partial<APIGatewayProxyEventV2> = {},
+): APIGatewayProxyEventV2 {
+  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: 1704067200000,
+      http: {
+        method: 'GET',
+        path: '/test',
+        protocol: 'HTTP/1.1',
+        sourceIp: '127.0.0.1',
+        userAgent: 'test-agent',
+      },
+    },
+    body: undefined,
+    pathParameters: undefined,
+    isBase64Encoded: false,
+    stageVariables: undefined,
+    queryStringParameters: undefined,
+    cookies: undefined,
+    ...overrides,
+  };
+}

package/src/logger.ts

@@ -0,0 +1,18 @@
+import type { Logger } from '@geekmidas/logger';
+import { vi } from 'vitest';
+
+/**
+ * Creates a mock Logger for testing
+ */
+export function createMockLogger(): Logger {
+  const logger: Logger = {
+    debug: vi.fn(),
+    info: vi.fn(),
+    warn: vi.fn(),
+    error: vi.fn(),
+    fatal: vi.fn(),
+    trace: vi.fn(),
+    child: vi.fn(() => logger),
+  };
+  return logger;
+}

package/src/os/directory.ts

@@ -0,0 +1,21 @@
+import crypto from 'node:crypto';
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { it } from 'vitest';
+
+export const itWithDir = it.extend<DirectoryFixtures>({
+  // This fixture automatically provides a transaction to each test
+  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 });
+  },
+});
+
+export interface DirectoryFixtures {
+  dir: string;
+}

package/src/os/index.ts

@@ -0,0 +1 @@
+export { itWithDir } from './directory';

package/src/timer.ts

@@ -0,0 +1,3 @@
+export function waitFor(ms: number) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}