@geekmidas/testkit 0.0.14 → 0.0.16

package/dist/kysely.mjs

@@ -1,10 +1,73 @@
 import "./Factory-z2m01hMj.mjs";
 import "./faker-BGKYFoCT.mjs";
 import { KyselyFactory } from "./KyselyFactory-BcYkC0t2.mjs";
-import "./PostgresMigrator-DxPC_gGu.mjs";
-import { PostgresKyselyMigrator } from "./PostgresKyselyMigrator-Bdhl251C.mjs";
+import "./PostgresMigrator-DbuJGAVy.mjs";
+import { PostgresKyselyMigrator } from "./PostgresKyselyMigrator-upT-hmrz.mjs";
 import { IsolationLevel } from "./VitestTransactionIsolator-CskiiJbW.mjs";
-import { VitestKyselyTransactionIsolator } from "./VitestKyselyTransactionIsolator-Dq4Oeh-Y.mjs";
-import { wrapVitestKyselyTransaction } from "./kysely-BsDbvw3r.mjs";
+import { VitestKyselyTransactionIsolator } from "./VitestKyselyTransactionIsolator-BxjlD1YM.mjs";
 
-export { IsolationLevel, KyselyFactory, PostgresKyselyMigrator, VitestKyselyTransactionIsolator, wrapVitestKyselyTransaction };
+//#region src/kysely.ts
+/**
+* Creates a wrapped Vitest test API with automatic transaction rollback for Kysely.
+* 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.
+*
+* @template Database - The database schema type
+* @param api - The Vitest test API (usually `test` from vitest)
+* @param db - The Kysely database 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 { wrapVitestKyselyTransaction } from '@geekmidas/testkit/kysely';
+* import { db } from './database';
+*
+* // Create isolated test with automatic rollback
+* const isolatedTest = wrapVitestKyselyTransaction(test, db);
+*
+* // Use in tests - each test gets its own transaction
+* isolatedTest('should create user', async ({ trx }) => {
+*   const user = await trx
+*     .insertInto('users')
+*     .values({ name: 'Test User', email: 'test@example.com' })
+*     .returningAll()
+*     .executeTakeFirst();
+*
+*   expect(user).toBeDefined();
+*   // User is automatically rolled back after test
+* });
+*
+* // With setup function for common test data
+* const testWithSetup = wrapVitestKyselyTransaction(
+*   test,
+*   db,
+*   async (trx) => {
+*     // Create common test data
+*     await trx.insertInto('settings')
+*       .values({ key: 'test_mode', value: 'true' })
+*       .execute();
+*   }
+* );
+*
+* testWithSetup('should have test settings', async ({ trx }) => {
+*   const setting = await trx
+*     .selectFrom('settings')
+*     .where('key', '=', 'test_mode')
+*     .selectAll()
+*     .executeTakeFirst();
+*
+*   expect(setting?.value).toBe('true');
+* });
+* ```
+*/
+function wrapVitestKyselyTransaction(api, connection, setup, level = IsolationLevel.REPEATABLE_READ) {
+	const wrapper = new VitestKyselyTransactionIsolator(api);
+	return wrapper.wrapVitestWithTransaction(connection, setup, level);
+}
+
+//#endregion
+export { IsolationLevel, KyselyFactory, PostgresKyselyMigrator, VitestKyselyTransactionIsolator, wrapVitestKyselyTransaction };
+//# sourceMappingURL=kysely.mjs.map

package/dist/kysely.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"kysely.mjs","names":["api: TestAPI","connection: DatabaseConnection<Kysely<Database>>","setup?: (trx: Transaction<Database>) => Promise<void>","level: IsolationLevel"],"sources":["../src/kysely.ts"],"sourcesContent":["import type { Kysely, Transaction } from 'kysely';\nimport type { TestAPI } from 'vitest';\nimport { VitestKyselyTransactionIsolator } from './VitestKyselyTransactionIsolator';\nimport {\n  type DatabaseConnection,\n  IsolationLevel,\n} from './VitestTransactionIsolator';\n\n/**\n * Kysely-specific exports for test utilities.\n * Provides factories, migrators, and transaction isolators for Kysely ORM.\n */\n\nexport { KyselyFactory } from './KyselyFactory';\nexport { PostgresKyselyMigrator } from './PostgresKyselyMigrator';\nexport { VitestKyselyTransactionIsolator } from './VitestKyselyTransactionIsolator';\nexport { IsolationLevel } from './VitestTransactionIsolator';\n\n/**\n * Creates a wrapped Vitest test API with automatic transaction rollback for Kysely.\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 * @template Database - The database schema type\n * @param api - The Vitest test API (usually `test` from vitest)\n * @param db - The Kysely database 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 { wrapVitestKyselyTransaction } from '@geekmidas/testkit/kysely';\n * import { db } from './database';\n *\n * // Create isolated test with automatic rollback\n * const isolatedTest = wrapVitestKyselyTransaction(test, db);\n *\n * // Use in tests - each test gets its own transaction\n * isolatedTest('should create user', async ({ trx }) => {\n *   const user = await trx\n *     .insertInto('users')\n *     .values({ name: 'Test User', email: 'test@example.com' })\n *     .returningAll()\n *     .executeTakeFirst();\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 = wrapVitestKyselyTransaction(\n *   test,\n *   db,\n *   async (trx) => {\n *     // Create common test data\n *     await trx.insertInto('settings')\n *       .values({ key: 'test_mode', value: 'true' })\n *       .execute();\n *   }\n * );\n *\n * testWithSetup('should have test settings', async ({ trx }) => {\n *   const setting = await trx\n *     .selectFrom('settings')\n *     .where('key', '=', 'test_mode')\n *     .selectAll()\n *     .executeTakeFirst();\n *\n *   expect(setting?.value).toBe('true');\n * });\n * ```\n */\nexport function wrapVitestKyselyTransaction<Database>(\n  api: TestAPI,\n  connection: DatabaseConnection<Kysely<Database>>,\n  setup?: (trx: Transaction<Database>) => Promise<void>,\n  level: IsolationLevel = IsolationLevel.REPEATABLE_READ,\n) {\n  const wrapper = new VitestKyselyTransactionIsolator<Database>(api);\n\n  return wrapper.wrapVitestWithTransaction(connection, setup, level);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA0EA,SAAgB,4BACdA,KACAC,YACAC,OACAC,QAAwB,eAAe,iBACvC;CACA,MAAM,UAAU,IAAI,gCAA0C;AAE9D,QAAO,QAAQ,0BAA0B,YAAY,OAAO,MAAM;AACnE"}

package/dist/logger.cjs

@@ -0,0 +1,23 @@
+const require_chunk = require('./chunk-CUT6urMc.cjs');
+const vitest = require_chunk.__toESM(require("vitest"));
+
+//#region src/logger.ts
+/**
+* Creates a mock Logger for testing
+*/
+function createMockLogger() {
+	const logger = {
+		debug: vitest.vi.fn(),
+		info: vitest.vi.fn(),
+		warn: vitest.vi.fn(),
+		error: vitest.vi.fn(),
+		fatal: vitest.vi.fn(),
+		trace: vitest.vi.fn(),
+		child: vitest.vi.fn(() => logger)
+	};
+	return logger;
+}
+
+//#endregion
+exports.createMockLogger = createMockLogger;
+//# sourceMappingURL=logger.cjs.map

package/dist/logger.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"logger.cjs","names":["logger: Logger"],"sources":["../src/logger.ts"],"sourcesContent":["import type { Logger } from '@geekmidas/logger';\nimport { vi } from 'vitest';\n\n/**\n * Creates a mock Logger for testing\n */\nexport function createMockLogger(): Logger {\n  const logger: Logger = {\n    debug: vi.fn(),\n    info: vi.fn(),\n    warn: vi.fn(),\n    error: vi.fn(),\n    fatal: vi.fn(),\n    trace: vi.fn(),\n    child: vi.fn(() => logger),\n  };\n  return logger;\n}\n"],"mappings":";;;;;;;AAMA,SAAgB,mBAA2B;CACzC,MAAMA,SAAiB;EACrB,OAAO,UAAG,IAAI;EACd,MAAM,UAAG,IAAI;EACb,MAAM,UAAG,IAAI;EACb,OAAO,UAAG,IAAI;EACd,OAAO,UAAG,IAAI;EACd,OAAO,UAAG,IAAI;EACd,OAAO,UAAG,GAAG,MAAM,OAAO;CAC3B;AACD,QAAO;AACR"}

package/dist/logger.d.cts

@@ -0,0 +1,11 @@
+import { Logger } from "@geekmidas/logger";
+
+//#region src/logger.d.ts
+
+/**
+ * Creates a mock Logger for testing
+ */
+declare function createMockLogger(): Logger;
+//#endregion
+export { createMockLogger };
+//# sourceMappingURL=logger.d.cts.map

package/dist/logger.d.mts

@@ -0,0 +1,11 @@
+import { Logger } from "@geekmidas/logger";
+
+//#region src/logger.d.ts
+
+/**
+ * Creates a mock Logger for testing
+ */
+declare function createMockLogger(): Logger;
+//#endregion
+export { createMockLogger };
+//# sourceMappingURL=logger.d.mts.map

package/dist/logger.mjs

@@ -0,0 +1,22 @@
+import { vi } from "vitest";
+
+//#region src/logger.ts
+/**
+* Creates a mock Logger for testing
+*/
+function createMockLogger() {
+	const 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;
+}
+
+//#endregion
+export { createMockLogger };
+//# sourceMappingURL=logger.mjs.map

package/dist/logger.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"logger.mjs","names":["logger: Logger"],"sources":["../src/logger.ts"],"sourcesContent":["import type { Logger } from '@geekmidas/logger';\nimport { vi } from 'vitest';\n\n/**\n * Creates a mock Logger for testing\n */\nexport function createMockLogger(): Logger {\n  const logger: Logger = {\n    debug: vi.fn(),\n    info: vi.fn(),\n    warn: vi.fn(),\n    error: vi.fn(),\n    fatal: vi.fn(),\n    trace: vi.fn(),\n    child: vi.fn(() => logger),\n  };\n  return logger;\n}\n"],"mappings":";;;;;;AAMA,SAAgB,mBAA2B;CACzC,MAAMA,SAAiB;EACrB,OAAO,GAAG,IAAI;EACd,MAAM,GAAG,IAAI;EACb,MAAM,GAAG,IAAI;EACb,OAAO,GAAG,IAAI;EACd,OAAO,GAAG,IAAI;EACd,OAAO,GAAG,IAAI;EACd,OAAO,GAAG,GAAG,MAAM,OAAO;CAC3B;AACD,QAAO;AACR"}

package/dist/objection.cjs

@@ -4,11 +4,89 @@ const require_ObjectionFactory = require('./ObjectionFactory-CDriunkS.cjs');
 require('./PostgresMigrator-DFcNdCvD.cjs');
 const require_PostgresObjectionMigrator = require('./PostgresObjectionMigrator-BG6ymgnt.cjs');
 const require_VitestTransactionIsolator = require('./VitestTransactionIsolator-BQ5FpLtC.cjs');
-const require_VitestObjectionTransactionIsolator = require('./VitestObjectionTransactionIsolator-LP4B0cqW.cjs');
-const require_objection = require('./objection-Di7JSist.cjs');
+const require_VitestObjectionTransactionIsolator = require('./VitestObjectionTransactionIsolator-DzeF4UAq.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-DVtJG2F3.mjs";
-import { wrapVitestObjectionTransaction } from "./objection-BEPk9h-g.mjs";
+import { VitestObjectionTransactionIsolator } from "./VitestObjectionTransactionIsolator-BU-jXEhz.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.14",
+  "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",
-    "@geekmidas/envkit": "0.0.6"
+    "@types/aws-lambda": ">=8.10.92",
+    "@geekmidas/envkit": "0.0.7"
   }
 }

package/src/VitestKyselyTransactionIsolator.ts

@@ -47,8 +47,8 @@ export class VitestKyselyTransactionIsolator<
   Kysely<Database>,
   Transaction<Database>
 > {
-  destroy(conn: Kysely<Database>): Promise<void> {
-    return conn.destroy();
+  async destroy(conn: Kysely<Database>): Promise<void> {
+    // return conn.destroy();
   }
   /**
    * Creates a Kysely transaction with the specified isolation level.

package/src/VitestObjectionTransactionIsolator.ts

@@ -36,9 +36,7 @@ export class VitestObjectionTransactionIsolator extends VitestPostgresTransactio
   Knex,
   Knex.Transaction
 > {
-  destroy(conn: Knex<any, any[]>): Promise<void> {
-    return conn.destroy();
-  }
+  async destroy(conn: Knex<any, any[]>): Promise<void> {}
   /**
    * Creates a Knex transaction with the specified isolation level.
    * Implements the abstract transact method from VitestPostgresTransactionIsolator.