@geekmidas/testkit 0.1.0 → 0.2.0

package/dist/objection.d.cts

@@ -1,24 +1,36 @@
-import { FakerFactory, faker } from "./faker-Cg76aFNO.cjs";
-import "./Factory-BZ8uMoXl.cjs";
-import { ObjectionFactory } from "./ObjectionFactory-CeSIN3kZ.cjs";
+import { FakerFactory, faker } from "./faker-Dg3trU4a.cjs";
+import "./Factory-D7oHtI2D.cjs";
+import { ObjectionFactory } from "./ObjectionFactory-0gUdx8bB.cjs";
 import "./PostgresMigrator-D5UkK1_K.cjs";
 import { PostgresObjectionMigrator } from "./PostgresObjectionMigrator-CZHHcCOv.cjs";
-import { DatabaseConnection, DatabaseFixtures, FixtureCreators, IsolationLevel } from "./VitestTransactionIsolator-CyG_i_Nj.cjs";
-import { VitestObjectionTransactionIsolator } from "./VitestObjectionTransactionIsolator-COVDlpEo.cjs";
+import { DatabaseConnection, DatabaseFixtures, ExtendedDatabaseFixtures, FixtureCreators, IsolationLevel, TestWithExtendedFixtures, TransactionWrapperOptions } from "./VitestTransactionIsolator-CwQaxZLP.cjs";
+import { VitestObjectionTransactionIsolator } from "./VitestObjectionTransactionIsolator-1TpsPqfG.cjs";
 import { Knex } from "knex";
 import { TestAPI } from "vitest";
 
 //#region src/objection.d.ts
 
+/**
+ * Objection.js-specific options for transaction wrapping.
+ */
+interface ObjectionTransactionOptions<Extended extends Record<string, unknown> = {}> {
+  /** Function that creates or returns a Knex database connection */
+  connection: DatabaseConnection<Knex>;
+  /** Optional setup function to run within the transaction before each test */
+  setup?: (trx: Knex.Transaction) => Promise<void>;
+  /** Transaction isolation level (defaults to REPEATABLE_READ) */
+  isolationLevel?: IsolationLevel;
+  /** Additional fixtures that depend on the transaction */
+  fixtures?: FixtureCreators<Knex.Transaction, Extended>;
+}
 /**
  * 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.
  *
+ * @template Extended - Additional fixtures to provide
  * @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)
+ * @param options - Configuration options for transaction wrapping
  * @returns A wrapped test API that provides transaction isolation
  *
  * @example
@@ -26,10 +38,12 @@ import { TestAPI } from "vitest";
  * import { test } from 'vitest';
  * import { wrapVitestObjectionTransaction } from '@geekmidas/testkit/objection';
  * import { knex } from './database';
- * import { User, Post } from './models';
+ * import { User } from './models';
  *
  * // Create isolated test with automatic rollback
- * const isolatedTest = wrapVitestObjectionTransaction(test, knex);
+ * const isolatedTest = wrapVitestObjectionTransaction(test, {
+ *   connection: knex,
+ * });
  *
  * // Use in tests - each test gets its own transaction
  * isolatedTest('should create user', async ({ trx }) => {
@@ -37,53 +51,23 @@ import { TestAPI } from "vitest";
  *     .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');
+ * // With fixtures for factories
+ * const it = wrapVitestObjectionTransaction<{ factory: Factory }>(test, {
+ *   connection: knex,
+ *   fixtures: {
+ *     factory: (trx) => new Factory(trx),
+ *   },
  * });
  *
- * // 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);
+ * it('should create user with factory', async ({ trx, factory }) => {
+ *   const user = await factory.insert('user', { name: 'Test' });
+ *   expect(user.id).toBeDefined();
  * });
  * ```
  */
-declare function wrapVitestObjectionTransaction(api: TestAPI, conn: DatabaseConnection<Knex>, setup?: (trx: Knex.Transaction) => Promise<void>, level?: IsolationLevel): TestAPI<{
-  trx: Knex.Transaction<any, any[]>;
-}>;
+declare function wrapVitestObjectionTransaction<Extended extends Record<string, unknown> = {}>(api: TestAPI, options: ObjectionTransactionOptions<Extended>): TestAPI<DatabaseFixtures<Knex.Transaction<any, any[]>, object> & Extended>;
 /**
  * Extends an Objection.js transaction-wrapped test with additional fixtures.
  * Each fixture receives the transaction and can create dependencies like factories or repositories.
@@ -108,7 +92,10 @@ declare function wrapVitestObjectionTransaction(api: TestAPI, conn: DatabaseConn
  * };
  *
  * // Create base wrapped test
- * const baseTest = wrapVitestObjectionTransaction(test, knex, createTestTables);
+ * const baseTest = wrapVitestObjectionTransaction(test, {
+ *   connection: knex,
+ *   setup: createTestTables,
+ * });
  *
  * // Extend with fixtures - each fixture receives the transaction
  * const it = extendWithFixtures<{ factory: ObjectionFactory<typeof builders, {}> }>(
@@ -129,10 +116,7 @@ declare function wrapVitestObjectionTransaction(api: TestAPI, conn: DatabaseConn
  * });
  * ```
  */
-declare function extendWithFixtures<Extended extends Record<string, unknown>, T extends ReturnType<TestAPI['extend']> = ReturnType<TestAPI['extend']>>(wrappedTest: T, fixtures: FixtureCreators<Knex.Transaction, Extended>): T & {
-  <C extends object>(name: string, fn: (context: DatabaseFixtures<Knex.Transaction<any, any[]>, object> & Extended & C) => Promise<void>): void;
-  <C extends object>(name: string, options: object, fn: (context: DatabaseFixtures<Knex.Transaction<any, any[]>, object> & Extended & C) => Promise<void>): void;
-};
+declare function extendWithFixtures<Extended extends Record<string, unknown>, T extends ReturnType<TestAPI['extend']> = ReturnType<TestAPI['extend']>>(wrappedTest: T, fixtures: FixtureCreators<Knex.Transaction, Extended>): TestWithExtendedFixtures<Knex.Transaction<any, any[]>, Extended, T>;
 //#endregion
-export { FakerFactory, FixtureCreators, IsolationLevel, ObjectionFactory, PostgresObjectionMigrator, VitestObjectionTransactionIsolator, extendWithFixtures, faker, wrapVitestObjectionTransaction };
+export { DatabaseFixtures, ExtendedDatabaseFixtures, FakerFactory, FixtureCreators, IsolationLevel, ObjectionFactory, ObjectionTransactionOptions, PostgresObjectionMigrator, TestWithExtendedFixtures, TransactionWrapperOptions, VitestObjectionTransactionIsolator, extendWithFixtures, faker, wrapVitestObjectionTransaction };
 //# sourceMappingURL=objection.d.cts.map

package/dist/objection.d.mts

@@ -3,22 +3,34 @@ import "./Factory-Cmr3s3-s.mjs";
 import { ObjectionFactory } from "./ObjectionFactory-BagGjikT.mjs";
 import "./PostgresMigrator-DQaRxoaY.mjs";
 import { PostgresObjectionMigrator } from "./PostgresObjectionMigrator-D_hCcrQu.mjs";
-import { DatabaseConnection, DatabaseFixtures, FixtureCreators, IsolationLevel } from "./VitestTransactionIsolator-DWDbnITQ.mjs";
-import { VitestObjectionTransactionIsolator } from "./VitestObjectionTransactionIsolator-lZUSz1w0.mjs";
+import { DatabaseConnection, DatabaseFixtures, ExtendedDatabaseFixtures, FixtureCreators, IsolationLevel, TestWithExtendedFixtures, TransactionWrapperOptions } from "./VitestTransactionIsolator-BvR19bYn.mjs";
+import { VitestObjectionTransactionIsolator } from "./VitestObjectionTransactionIsolator-i9jIgU8Q.mjs";
 import { TestAPI } from "vitest";
 import { Knex } from "knex";
 
 //#region src/objection.d.ts
 
+/**
+ * Objection.js-specific options for transaction wrapping.
+ */
+interface ObjectionTransactionOptions<Extended extends Record<string, unknown> = {}> {
+  /** Function that creates or returns a Knex database connection */
+  connection: DatabaseConnection<Knex>;
+  /** Optional setup function to run within the transaction before each test */
+  setup?: (trx: Knex.Transaction) => Promise<void>;
+  /** Transaction isolation level (defaults to REPEATABLE_READ) */
+  isolationLevel?: IsolationLevel;
+  /** Additional fixtures that depend on the transaction */
+  fixtures?: FixtureCreators<Knex.Transaction, Extended>;
+}
 /**
  * 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.
  *
+ * @template Extended - Additional fixtures to provide
  * @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)
+ * @param options - Configuration options for transaction wrapping
  * @returns A wrapped test API that provides transaction isolation
  *
  * @example
@@ -26,10 +38,12 @@ import { Knex } from "knex";
  * import { test } from 'vitest';
  * import { wrapVitestObjectionTransaction } from '@geekmidas/testkit/objection';
  * import { knex } from './database';
- * import { User, Post } from './models';
+ * import { User } from './models';
  *
  * // Create isolated test with automatic rollback
- * const isolatedTest = wrapVitestObjectionTransaction(test, knex);
+ * const isolatedTest = wrapVitestObjectionTransaction(test, {
+ *   connection: knex,
+ * });
  *
  * // Use in tests - each test gets its own transaction
  * isolatedTest('should create user', async ({ trx }) => {
@@ -37,53 +51,23 @@ import { Knex } from "knex";
  *     .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');
+ * // With fixtures for factories
+ * const it = wrapVitestObjectionTransaction<{ factory: Factory }>(test, {
+ *   connection: knex,
+ *   fixtures: {
+ *     factory: (trx) => new Factory(trx),
+ *   },
  * });
  *
- * // 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);
+ * it('should create user with factory', async ({ trx, factory }) => {
+ *   const user = await factory.insert('user', { name: 'Test' });
+ *   expect(user.id).toBeDefined();
  * });
  * ```
  */
-declare function wrapVitestObjectionTransaction(api: TestAPI, conn: DatabaseConnection<Knex>, setup?: (trx: Knex.Transaction) => Promise<void>, level?: IsolationLevel): TestAPI<{
-  trx: Knex.Transaction<any, any[]>;
-}>;
+declare function wrapVitestObjectionTransaction<Extended extends Record<string, unknown> = {}>(api: TestAPI, options: ObjectionTransactionOptions<Extended>): TestAPI<DatabaseFixtures<Knex.Transaction<any, any[]>, object> & Extended>;
 /**
  * Extends an Objection.js transaction-wrapped test with additional fixtures.
  * Each fixture receives the transaction and can create dependencies like factories or repositories.
@@ -108,7 +92,10 @@ declare function wrapVitestObjectionTransaction(api: TestAPI, conn: DatabaseConn
  * };
  *
  * // Create base wrapped test
- * const baseTest = wrapVitestObjectionTransaction(test, knex, createTestTables);
+ * const baseTest = wrapVitestObjectionTransaction(test, {
+ *   connection: knex,
+ *   setup: createTestTables,
+ * });
  *
  * // Extend with fixtures - each fixture receives the transaction
  * const it = extendWithFixtures<{ factory: ObjectionFactory<typeof builders, {}> }>(
@@ -129,10 +116,7 @@ declare function wrapVitestObjectionTransaction(api: TestAPI, conn: DatabaseConn
  * });
  * ```
  */
-declare function extendWithFixtures<Extended extends Record<string, unknown>, T extends ReturnType<TestAPI['extend']> = ReturnType<TestAPI['extend']>>(wrappedTest: T, fixtures: FixtureCreators<Knex.Transaction, Extended>): T & {
-  <C extends object>(name: string, fn: (context: DatabaseFixtures<Knex.Transaction<any, any[]>, object> & Extended & C) => Promise<void>): void;
-  <C extends object>(name: string, options: object, fn: (context: DatabaseFixtures<Knex.Transaction<any, any[]>, object> & Extended & C) => Promise<void>): void;
-};
+declare function extendWithFixtures<Extended extends Record<string, unknown>, T extends ReturnType<TestAPI['extend']> = ReturnType<TestAPI['extend']>>(wrappedTest: T, fixtures: FixtureCreators<Knex.Transaction, Extended>): TestWithExtendedFixtures<Knex.Transaction<any, any[]>, Extended, T>;
 //#endregion
-export { FakerFactory, FixtureCreators, IsolationLevel, ObjectionFactory, PostgresObjectionMigrator, VitestObjectionTransactionIsolator, extendWithFixtures, faker, wrapVitestObjectionTransaction };
+export { DatabaseFixtures, ExtendedDatabaseFixtures, FakerFactory, FixtureCreators, IsolationLevel, ObjectionFactory, ObjectionTransactionOptions, PostgresObjectionMigrator, TestWithExtendedFixtures, TransactionWrapperOptions, VitestObjectionTransactionIsolator, extendWithFixtures, faker, wrapVitestObjectionTransaction };
 //# sourceMappingURL=objection.d.mts.map

package/dist/objection.mjs

@@ -3,8 +3,8 @@ import { faker } from "./faker-BGKYFoCT.mjs";
 import { ObjectionFactory } from "./ObjectionFactory-zf2fLKrL.mjs";
 import "./PostgresMigrator-DbuJGAVy.mjs";
 import { PostgresObjectionMigrator } from "./PostgresObjectionMigrator-DPj2pOpX.mjs";
-import { IsolationLevel, extendWithFixtures } from "./VitestTransactionIsolator-BIaMs4c2.mjs";
-import { VitestObjectionTransactionIsolator } from "./VitestObjectionTransactionIsolator-_EhJKu_O.mjs";
+import { IsolationLevel, extendWithFixtures } from "./VitestTransactionIsolator-DQ7tLqgV.mjs";
+import { VitestObjectionTransactionIsolator } from "./VitestObjectionTransactionIsolator-jQFaCz0u.mjs";
 
 //#region src/objection.ts
 /**
@@ -12,10 +12,9 @@ import { VitestObjectionTransactionIsolator } from "./VitestObjectionTransaction
 * 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 Extended - Additional fixtures to provide
 * @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)
+* @param options - Configuration options for transaction wrapping
 * @returns A wrapped test API that provides transaction isolation
 *
 * @example
@@ -23,10 +22,12 @@ import { VitestObjectionTransactionIsolator } from "./VitestObjectionTransaction
 * import { test } from 'vitest';
 * import { wrapVitestObjectionTransaction } from '@geekmidas/testkit/objection';
 * import { knex } from './database';
-* import { User, Post } from './models';
+* import { User } from './models';
 *
 * // Create isolated test with automatic rollback
-* const isolatedTest = wrapVitestObjectionTransaction(test, knex);
+* const isolatedTest = wrapVitestObjectionTransaction(test, {
+*   connection: knex,
+* });
 *
 * // Use in tests - each test gets its own transaction
 * isolatedTest('should create user', async ({ trx }) => {
@@ -34,53 +35,25 @@ import { VitestObjectionTransactionIsolator } from "./VitestObjectionTransaction
 *     .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');
+* // With fixtures for factories
+* const it = wrapVitestObjectionTransaction<{ factory: Factory }>(test, {
+*   connection: knex,
+*   fixtures: {
+*     factory: (trx) => new Factory(trx),
+*   },
 * });
 *
-* // 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);
+* it('should create user with factory', async ({ trx, factory }) => {
+*   const user = await factory.insert('user', { name: 'Test' });
+*   expect(user.id).toBeDefined();
 * });
 * ```
 */
-function wrapVitestObjectionTransaction(api, conn, setup, level = IsolationLevel.REPEATABLE_READ) {
+function wrapVitestObjectionTransaction(api, options) {
 	const wrapper = new VitestObjectionTransactionIsolator(api);
-	return wrapper.wrapVitestWithTransaction(conn, setup, level);
+	return wrapper.wrapVitestWithTransaction(options);
 }
 /**
 * Extends an Objection.js transaction-wrapped test with additional fixtures.
@@ -106,7 +79,10 @@ function wrapVitestObjectionTransaction(api, conn, setup, level = IsolationLevel
 * };
 *
 * // Create base wrapped test
-* const baseTest = wrapVitestObjectionTransaction(test, knex, createTestTables);
+* const baseTest = wrapVitestObjectionTransaction(test, {
+*   connection: knex,
+*   setup: createTestTables,
+* });
 *
 * // Extend with fixtures - each fixture receives the transaction
 * const it = extendWithFixtures<{ factory: ObjectionFactory<typeof builders, {}> }>(

package/dist/objection.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"objection.mjs","names":["api: TestAPI","conn: DatabaseConnection<Knex>","setup?: (trx: Knex.Transaction) => Promise<void>","level: IsolationLevel","extendWithFixtures","wrappedTest: T","fixtures: FixtureCreators<Knex.Transaction, Extended>"],"sources":["../src/objection.ts"],"sourcesContent":["import type { Knex } from 'knex';\nimport type { TestAPI } from 'vitest';\nimport { VitestObjectionTransactionIsolator } from './VitestObjectionTransactionIsolator';\nimport {\n  type DatabaseConnection,\n  type FixtureCreators,\n  IsolationLevel,\n  extendWithFixtures as baseExtendWithFixtures,\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';\nexport type { FixtureCreators } from './VitestTransactionIsolator';\n\n// Re-export faker and FakerFactory for type portability in declaration files\nexport { faker, type FakerFactory } from './faker';\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\n/**\n * Extends an Objection.js transaction-wrapped test with additional fixtures.\n * Each fixture receives the transaction and can create dependencies like factories or repositories.\n *\n * @template Extended - The type of additional fixtures to provide\n * @param wrappedTest - The base wrapped test from wrapVitestObjectionTransaction\n * @param fixtures - Object mapping fixture names to creator functions\n * @returns An extended test API with both trx and the additional fixtures\n *\n * @example\n * ```typescript\n * import { test } from 'vitest';\n * import { wrapVitestObjectionTransaction, extendWithFixtures, ObjectionFactory } from '@geekmidas/testkit/objection';\n * import { User } from './models';\n *\n * // Define your builders\n * const builders = {\n *   user: ObjectionFactory.createBuilder(User, ({ faker }) => ({\n *     name: faker.person.fullName(),\n *     email: faker.internet.email(),\n *   })),\n * };\n *\n * // Create base wrapped test\n * const baseTest = wrapVitestObjectionTransaction(test, knex, createTestTables);\n *\n * // Extend with fixtures - each fixture receives the transaction\n * const it = extendWithFixtures<{ factory: ObjectionFactory<typeof builders, {}> }>(\n *   baseTest,\n *   {\n *     factory: (trx) => new ObjectionFactory(builders, {}, trx),\n *   }\n * );\n *\n * // Use in tests - both trx and factory are available\n * it('should create user with factory', async ({ trx, factory }) => {\n *   const user = await factory.insert('user', { name: 'Test User' });\n *   expect(user.id).toBeDefined();\n *\n *   // Verify in database\n *   const found = await User.query(trx).findById(user.id);\n *   expect(found?.name).toBe('Test User');\n * });\n * ```\n */\nexport function extendWithFixtures<\n  Extended extends Record<string, unknown>,\n  T extends ReturnType<TestAPI['extend']> = ReturnType<TestAPI['extend']>,\n>(wrappedTest: T, fixtures: FixtureCreators<Knex.Transaction, Extended>) {\n  return baseExtendWithFixtures<Knex.Transaction, Extended, T>(\n    wrappedTest,\n    fixtures,\n  );\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgGA,SAAgB,+BACdA,KACAC,MACAC,OACAC,QAAwB,eAAe,iBACvC;CACA,MAAM,UAAU,IAAI,mCAAmC;AAEvD,QAAO,QAAQ,0BAA0B,MAAM,OAAO,MAAM;AAC7D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+CD,SAAgBC,qBAGdC,aAAgBC,UAAuD;AACvE,QAAO,mBACL,aACA,SACD;AACF"}
+{"version":3,"file":"objection.mjs","names":["api: TestAPI","options: ObjectionTransactionOptions<Extended>","extendWithFixtures","wrappedTest: T","fixtures: FixtureCreators<Knex.Transaction, Extended>"],"sources":["../src/objection.ts"],"sourcesContent":["import type { Knex } from 'knex';\nimport type { TestAPI } from 'vitest';\nimport { VitestObjectionTransactionIsolator } from './VitestObjectionTransactionIsolator';\nimport {\n  type DatabaseConnection,\n  type FixtureCreators,\n  type IsolationLevel,\n  extendWithFixtures as baseExtendWithFixtures,\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';\nexport type {\n  DatabaseFixtures,\n  ExtendedDatabaseFixtures,\n  FixtureCreators,\n  TestWithExtendedFixtures,\n  TransactionWrapperOptions,\n} from './VitestTransactionIsolator';\n\n/**\n * Objection.js-specific options for transaction wrapping.\n */\nexport interface ObjectionTransactionOptions<\n  Extended extends Record<string, unknown> = {},\n> {\n  /** Function that creates or returns a Knex database connection */\n  connection: DatabaseConnection<Knex>;\n  /** Optional setup function to run within the transaction before each test */\n  setup?: (trx: Knex.Transaction) => Promise<void>;\n  /** Transaction isolation level (defaults to REPEATABLE_READ) */\n  isolationLevel?: IsolationLevel;\n  /** Additional fixtures that depend on the transaction */\n  fixtures?: FixtureCreators<Knex.Transaction, Extended>;\n}\n\n// Re-export faker and FakerFactory for type portability in declaration files\nexport { faker, type FakerFactory } from './faker';\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 * @template Extended - Additional fixtures to provide\n * @param api - The Vitest test API (usually `test` from vitest)\n * @param options - Configuration options for transaction wrapping\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 } from './models';\n *\n * // Create isolated test with automatic rollback\n * const isolatedTest = wrapVitestObjectionTransaction(test, {\n *   connection: knex,\n * });\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 * });\n *\n * // With fixtures for factories\n * const it = wrapVitestObjectionTransaction<{ factory: Factory }>(test, {\n *   connection: knex,\n *   fixtures: {\n *     factory: (trx) => new Factory(trx),\n *   },\n * });\n *\n * it('should create user with factory', async ({ trx, factory }) => {\n *   const user = await factory.insert('user', { name: 'Test' });\n *   expect(user.id).toBeDefined();\n * });\n * ```\n */\nexport function wrapVitestObjectionTransaction<\n  Extended extends Record<string, unknown> = {},\n>(api: TestAPI, options: ObjectionTransactionOptions<Extended>) {\n  const wrapper = new VitestObjectionTransactionIsolator(api);\n\n  return wrapper.wrapVitestWithTransaction(options);\n}\n\n/**\n * Extends an Objection.js transaction-wrapped test with additional fixtures.\n * Each fixture receives the transaction and can create dependencies like factories or repositories.\n *\n * @template Extended - The type of additional fixtures to provide\n * @param wrappedTest - The base wrapped test from wrapVitestObjectionTransaction\n * @param fixtures - Object mapping fixture names to creator functions\n * @returns An extended test API with both trx and the additional fixtures\n *\n * @example\n * ```typescript\n * import { test } from 'vitest';\n * import { wrapVitestObjectionTransaction, extendWithFixtures, ObjectionFactory } from '@geekmidas/testkit/objection';\n * import { User } from './models';\n *\n * // Define your builders\n * const builders = {\n *   user: ObjectionFactory.createBuilder(User, ({ faker }) => ({\n *     name: faker.person.fullName(),\n *     email: faker.internet.email(),\n *   })),\n * };\n *\n * // Create base wrapped test\n * const baseTest = wrapVitestObjectionTransaction(test, {\n *   connection: knex,\n *   setup: createTestTables,\n * });\n *\n * // Extend with fixtures - each fixture receives the transaction\n * const it = extendWithFixtures<{ factory: ObjectionFactory<typeof builders, {}> }>(\n *   baseTest,\n *   {\n *     factory: (trx) => new ObjectionFactory(builders, {}, trx),\n *   }\n * );\n *\n * // Use in tests - both trx and factory are available\n * it('should create user with factory', async ({ trx, factory }) => {\n *   const user = await factory.insert('user', { name: 'Test User' });\n *   expect(user.id).toBeDefined();\n *\n *   // Verify in database\n *   const found = await User.query(trx).findById(user.id);\n *   expect(found?.name).toBe('Test User');\n * });\n * ```\n */\nexport function extendWithFixtures<\n  Extended extends Record<string, unknown>,\n  T extends ReturnType<TestAPI['extend']> = ReturnType<TestAPI['extend']>,\n>(wrappedTest: T, fixtures: FixtureCreators<Knex.Transaction, Extended>) {\n  return baseExtendWithFixtures<Knex.Transaction, Extended, T>(\n    wrappedTest,\n    fixtures,\n  );\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA2FA,SAAgB,+BAEdA,KAAcC,SAAgD;CAC9D,MAAM,UAAU,IAAI,mCAAmC;AAEvD,QAAO,QAAQ,0BAA0B,QAAQ;AAClD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkDD,SAAgBC,qBAGdC,aAAgBC,UAAuD;AACvE,QAAO,mBACL,aACA,SACD;AACF"}

package/dist/os/directory.d.cts

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

package/dist/os/index.d.cts

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@geekmidas/testkit",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "private": false,
   "type": "module",
   "exports": {

package/src/VitestTransactionIsolator.ts

@@ -124,30 +124,59 @@ export abstract class VitestPostgresTransactionIsolator<TConn, Transaction> {
    * Creates a wrapped version of Vitest's test API that provides transaction isolation.
    * Each test will run within a database transaction that is automatically rolled back.
    *
-   * @param conn - The database connection to use
-   * @param setup - Optional setup function to run within the transaction before each test
-   * @param level - The transaction isolation level (defaults to REPEATABLE_READ)
+   * @param options - Configuration options for transaction wrapping
    * @returns A wrapped test API with transaction support
    *
    * @example
    * ```typescript
-   * const isolatedTest = isolator.wrapVitestWithTransaction(db, async (trx) => {
-   *   // Optional setup: create common test data
-   *   await trx.insert('settings', { key: 'test', value: 'true' });
+   * const isolatedTest = isolator.wrapVitestWithTransaction({
+   *   connection: db,
+   *   setup: async (trx) => {
+   *     await trx.insert('settings', { key: 'test', value: 'true' });
+   *   },
+   *   fixtures: {
+   *     factory: (trx) => new Factory(trx),
+   *   },
    * });
    *
-   * isolatedTest('test with transaction', async ({ trx }) => {
-   *   const user = await trx.insert('users', { name: 'Test' });
+   * isolatedTest('test with transaction', async ({ trx, factory }) => {
+   *   const user = await factory.insert('user', { name: 'Test' });
    *   expect(user).toBeDefined();
    * });
    * ```
    */
-  wrapVitestWithTransaction(
-    createConnection: DatabaseConnection<TConn>,
-    setup?: (trx: Transaction) => Promise<void>,
-    level: IsolationLevel = IsolationLevel.REPEATABLE_READ,
+  wrapVitestWithTransaction<Extended extends Record<string, unknown> = {}>(
+    options: TransactionWrapperOptions<TConn, Transaction, Extended>,
   ) {
-    return this.api.extend<DatabaseFixtures<Transaction>>({
+    const {
+      connection,
+      setup,
+      isolationLevel = IsolationLevel.REPEATABLE_READ,
+      fixtures,
+    } = options;
+
+    // Build fixture definitions for additional fixtures that depend on trx
+    const additionalFixtures: Record<string, unknown> = {};
+    if (fixtures) {
+      for (const [key, creator] of Object.entries(fixtures)) {
+        additionalFixtures[key] = async (
+          { trx }: { trx: Transaction },
+          use: (value: unknown) => Promise<void>,
+        ) => {
+          const value = await (creator as (trx: Transaction) => unknown)(trx);
+          await use(value);
+        };
+      }
+    }
+
+    type CombinedFixtures = DatabaseFixtures<Transaction> & Extended;
+
+    // Cast to bypass Vitest's strict fixture typing which can't infer
+    // dynamically built fixture objects
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const extendFn = this.api.extend as <T>(fixtures: any) => TestAPI<T>;
+
+    return extendFn<CombinedFixtures>({
       // This fixture automatically provides a transaction to each test
       trx: async ({}, use: (value: Transaction) => Promise<void>) => {
         // Create a custom error class for rollback
@@ -159,9 +188,9 @@ export abstract class VitestPostgresTransactionIsolator<TConn, Transaction> {
         }
 
         let testError: Error | undefined;
-        const conn = await createConnection();
+        const conn = await connection();
         try {
-          await this.transact(conn, level, async (transaction) => {
+          await this.transact(conn, isolationLevel, async (transaction) => {
             try {
               // Provide the transaction to the test
               await setup?.(transaction);
@@ -188,6 +217,7 @@ export abstract class VitestPostgresTransactionIsolator<TConn, Transaction> {
           await this.destroy(conn);
         }
       },
+      ...additionalFixtures,
     });
   }
 }
@@ -195,6 +225,24 @@ export abstract class VitestPostgresTransactionIsolator<TConn, Transaction> {
 export type DatabaseConnectionFn<Conn> = () => Conn | Promise<Conn>;
 export type DatabaseConnection<Conn> = DatabaseConnectionFn<Conn>;
 
+/**
+ * Options for wrapping Vitest tests with database transaction isolation.
+ */
+export interface TransactionWrapperOptions<
+  TConn,
+  Transaction,
+  Extended extends Record<string, unknown> = {},
+> {
+  /** Function that creates or returns a database connection */
+  connection: DatabaseConnection<TConn>;
+  /** Optional setup function to run within the transaction before each test */
+  setup?: (trx: Transaction) => Promise<void>;
+  /** Transaction isolation level (defaults to REPEATABLE_READ) */
+  isolationLevel?: IsolationLevel;
+  /** Additional fixtures that depend on the transaction */
+  fixtures?: FixtureCreators<Transaction, Extended>;
+}
+
 /**
  * Type for fixture creator functions that depend on the transaction.
  * Each function receives the transaction and returns the fixture value.
@@ -208,6 +256,36 @@ export type FixtureCreators<
   ) => Extended[K] | Promise<Extended[K]>;
 };
 
+/**
+ * The test API returned by extendWithFixtures.
+ * Provides access to both the transaction (trx) and all extended fixtures.
+ *
+ * @template Transaction - The transaction type
+ * @template Extended - The type of additional fixtures provided
+ * @template BaseTest - The base wrapped test type
+ */
+export type TestWithExtendedFixtures<
+  Transaction,
+  Extended extends Record<string, unknown>,
+  BaseTest extends ReturnType<TestAPI['extend']> = ReturnType<
+    TestAPI['extend']
+  >,
+> = BaseTest & {
+  <C extends object>(
+    name: string,
+    fn: (
+      context: DatabaseFixtures<Transaction> & Extended & C,
+    ) => Promise<void>,
+  ): void;
+  <C extends object>(
+    name: string,
+    options: object,
+    fn: (
+      context: DatabaseFixtures<Transaction> & Extended & C,
+    ) => Promise<void>,
+  ): void;
+};
+
 /**
  * Extends a wrapped test API with additional fixtures that depend on the transaction.
  * This allows composing test context with factories, repositories, or other helpers.
@@ -223,7 +301,10 @@ export type FixtureCreators<
  * import { wrapVitestKyselyTransaction, extendWithFixtures } from '@geekmidas/testkit/kysely';
  *
  * // Create base wrapped test
- * const baseTest = wrapVitestKyselyTransaction(test, db, createTestTables);
+ * const baseTest = wrapVitestKyselyTransaction(test, {
+ *   connection: db,
+ *   setup: createTestTables,
+ * });
  *
  * // Extend with fixtures
  * const it = extendWithFixtures(baseTest, {
@@ -246,21 +327,7 @@ export function extendWithFixtures<
 >(
   wrappedTest: T,
   fixtures: FixtureCreators<Transaction, Extended>,
-): T & {
-  <C extends object>(
-    name: string,
-    fn: (
-      context: DatabaseFixtures<Transaction> & Extended & C,
-    ) => Promise<void>,
-  ): void;
-  <C extends object>(
-    name: string,
-    options: object,
-    fn: (
-      context: DatabaseFixtures<Transaction> & Extended & C,
-    ) => Promise<void>,
-  ): void;
-} {
+): TestWithExtendedFixtures<Transaction, Extended, T> {
   // Build fixture definitions for Vitest's extend API
   const fixtureDefinitions: Record<string, any> = {};