@geekmidas/testkit 0.0.9 → 0.0.11

package/dist/faker-nN9Ki6fn.d.mts

@@ -0,0 +1,155 @@
+import * as _faker_js_faker4 from "@faker-js/faker";
+
+//#region src/faker.d.ts
+
+/**
+ * Generates random timestamp fields for database records.
+ * Creates a createdAt date in the past and an updatedAt date between creation and now.
+ * Milliseconds are set to 0 for cleaner database storage.
+ *
+ * @returns Object with createdAt and updatedAt Date fields
+ *
+ * @example
+ * ```typescript
+ * const { createdAt, updatedAt } = timestamps();
+ * console.log(createdAt); // 2023-05-15T10:30:00.000Z
+ * console.log(updatedAt); // 2023-11-20T14:45:00.000Z
+ *
+ * // Use in factory
+ * const user = {
+ *   name: 'John Doe',
+ *   ...timestamps()
+ * };
+ * ```
+ */
+declare function timestamps(): Timestamps;
+/**
+ * Generates a reverse domain name identifier.
+ * Useful for creating unique identifiers that follow domain naming conventions.
+ *
+ * @param suffix - Optional suffix to append to the identifier
+ * @returns A reverse domain name string (e.g., "com.example.feature123")
+ *
+ * @example
+ * ```typescript
+ * console.log(identifier()); // "com.example.widget1"
+ * console.log(identifier('user')); // "org.acme.user"
+ * console.log(identifier('api')); // "net.demo.api"
+ * ```
+ */
+declare function identifier(suffix?: string): string;
+/**
+ * Generates sequential numbers for a named sequence.
+ * Useful for creating unique IDs or numbered test data.
+ * Each named sequence maintains its own counter.
+ *
+ * @param name - The sequence name (default: 'default')
+ * @returns The next number in the sequence
+ *
+ * @example
+ * ```typescript
+ * console.log(sequence()); // 1
+ * console.log(sequence()); // 2
+ * console.log(sequence('user')); // 1
+ * console.log(sequence('user')); // 2
+ * console.log(sequence()); // 3
+ *
+ * // Use in factories
+ * const email = `user${sequence('email')}@example.com`;
+ * ```
+ */
+declare function sequence(name?: string): number;
+/**
+ * Resets a named sequence counter to a specific value.
+ * Useful for resetting sequences between test suites.
+ *
+ * @param name - The sequence name to reset (default: 'default')
+ * @param value - The new starting value (default: 0)
+ *
+ * @example
+ * ```typescript
+ * sequence('user'); // 1
+ * sequence('user'); // 2
+ * resetSequence('user');
+ * sequence('user'); // 1
+ *
+ * resetSequence('order', 1000);
+ * sequence('order'); // 1001
+ * ```
+ */
+declare function resetSequence(name?: string, value?: number): void;
+/**
+ * Resets all sequence counters.
+ * Useful for cleaning up between test suites to ensure predictable sequences.
+ *
+ * @example
+ * ```typescript
+ * // In test setup
+ * beforeEach(() => {
+ *   resetAllSequences();
+ * });
+ *
+ * it('starts sequences from 1', () => {
+ *   expect(sequence()).toBe(1);
+ *   expect(sequence('user')).toBe(1);
+ * });
+ * ```
+ */
+declare function resetAllSequences(): void;
+/**
+ * Generates a random price as a number.
+ * Converts faker's string price to a numeric value.
+ *
+ * @returns A random price number
+ *
+ * @example
+ * ```typescript
+ * const productPrice = price(); // 29.99
+ * const total = price() * quantity; // Numeric calculation
+ * ```
+ */
+declare function price(): number;
+/**
+ * Enhanced faker instance with additional utility methods for testing.
+ * Extends @faker-js/faker with custom methods for common test data generation patterns.
+ *
+ * @example
+ * ```typescript
+ * import { faker } from '@geekmidas/testkit';
+ *
+ * // Use standard faker methods
+ * const name = faker.person.fullName();
+ * const email = faker.internet.email();
+ *
+ * // Use custom extensions
+ * const { createdAt, updatedAt } = faker.timestamps();
+ * const id = faker.identifier('user');
+ * const orderNumber = faker.sequence('order');
+ * const productPrice = faker.price();
+ * ```
+ */
+declare const faker$1: Readonly<_faker_js_faker4.Faker & {
+  timestamps: typeof timestamps;
+  identifier: typeof identifier;
+  sequence: typeof sequence;
+  resetSequence: typeof resetSequence;
+  resetAllSequences: typeof resetAllSequences;
+  price: typeof price;
+}>;
+/**
+ * Type definition for timestamp fields.
+ * Used by the timestamps() function to generate date fields.
+ */
+type Timestamps = {
+  /** The creation date */
+  createdAt: Date;
+  /** The last update date */
+  updatedAt: Date;
+};
+/**
+ * Type definition for the enhanced faker factory.
+ * Includes all standard faker methods plus custom extensions.
+ */
+type FakerFactory = typeof faker$1;
+//#endregion
+export { FakerFactory, Timestamps, faker$1 as faker, identifier, resetAllSequences, resetSequence, sequence, timestamps };

package/dist/faker.d.cts

@@ -0,0 +1,2 @@
+import { FakerFactory, Timestamps, faker, identifier, resetAllSequences, resetSequence, sequence, timestamps } from "./faker-DAiFK3T3.cjs";
+export { FakerFactory, Timestamps, faker, identifier, resetAllSequences, resetSequence, sequence, timestamps };

package/dist/faker.d.mts

@@ -0,0 +1,2 @@
+import { FakerFactory, Timestamps, faker, identifier, resetAllSequences, resetSequence, sequence, timestamps } from "./faker-nN9Ki6fn.mjs";
+export { FakerFactory, Timestamps, faker, identifier, resetAllSequences, resetSequence, sequence, timestamps };

package/dist/helpers.d.cts

@@ -0,0 +1,41 @@
+import { Kysely } from "kysely";
+
+//#region src/helpers.d.ts
+
+/**
+ * Creates a Kysely database instance with PostgreSQL dialect and camelCase plugin.
+ * This is a convenience function for quickly setting up a Kysely connection for testing.
+ *
+ * @template Database - The database schema type
+ * @param config - PostgreSQL connection configuration (pg.Pool config)
+ * @returns A configured Kysely instance
+ *
+ * @example
+ * ```typescript
+ * interface Database {
+ *   users: UsersTable;
+ *   posts: PostsTable;
+ * }
+ *
+ * // Create from connection string
+ * const db = createKyselyDb<Database>({
+ *   connectionString: 'postgresql://user:pass@localhost:5432/testdb'
+ * });
+ *
+ * // Create with detailed config
+ * const db = createKyselyDb<Database>({
+ *   host: 'localhost',
+ *   port: 5432,
+ *   database: 'testdb',
+ *   user: 'testuser',
+ *   password: 'testpass',
+ *   max: 10 // connection pool size
+ * });
+ *
+ * // Use in tests
+ * const users = await db.selectFrom('users').selectAll().execute();
+ * ```
+ */
+declare function createKyselyDb<Database>(config: any): Kysely<Database>;
+//#endregion
+export { createKyselyDb };

package/dist/helpers.d.mts

@@ -0,0 +1,41 @@
+import { Kysely } from "kysely";
+
+//#region src/helpers.d.ts
+
+/**
+ * Creates a Kysely database instance with PostgreSQL dialect and camelCase plugin.
+ * This is a convenience function for quickly setting up a Kysely connection for testing.
+ *
+ * @template Database - The database schema type
+ * @param config - PostgreSQL connection configuration (pg.Pool config)
+ * @returns A configured Kysely instance
+ *
+ * @example
+ * ```typescript
+ * interface Database {
+ *   users: UsersTable;
+ *   posts: PostsTable;
+ * }
+ *
+ * // Create from connection string
+ * const db = createKyselyDb<Database>({
+ *   connectionString: 'postgresql://user:pass@localhost:5432/testdb'
+ * });
+ *
+ * // Create with detailed config
+ * const db = createKyselyDb<Database>({
+ *   host: 'localhost',
+ *   port: 5432,
+ *   database: 'testdb',
+ *   user: 'testuser',
+ *   password: 'testpass',
+ *   max: 10 // connection pool size
+ * });
+ *
+ * // Use in tests
+ * const users = await db.selectFrom('users').selectAll().execute();
+ * ```
+ */
+declare function createKyselyDb<Database>(config: any): Kysely<Database>;
+//#endregion
+export { createKyselyDb };

package/dist/kysely.cjs

@@ -1,8 +1,8 @@
 require('./Factory-WMhTNZ9S.cjs');
 require('./faker-SMN4ira4.cjs');
 const require_KyselyFactory = require('./KyselyFactory-Bdq1s1Go.cjs');
-require('./PostgresMigrator-BtAWdLss.cjs');
-const require_PostgresKyselyMigrator = require('./PostgresKyselyMigrator-Bs31emFd.cjs');
+require('./PostgresMigrator-DFcNdCvD.cjs');
+const require_PostgresKyselyMigrator = require('./PostgresKyselyMigrator-CfytARcA.cjs');
 const require_VitestTransactionIsolator = require('./VitestTransactionIsolator-CruLTRRi.cjs');
 const require_VitestKyselyTransactionIsolator = require('./VitestKyselyTransactionIsolator-CIlpIO78.cjs');
 const require_kysely = require('./kysely-CBfCXxUn.cjs');

package/dist/kysely.d.cts

@@ -0,0 +1,73 @@
+import "./faker-DAiFK3T3.cjs";
+import "./Factory-B9LP1L18.cjs";
+import { KyselyFactory } from "./KyselyFactory-CrLWxJW4.cjs";
+import "./PostgresMigrator-D5UkK1_K.cjs";
+import { PostgresKyselyMigrator } from "./PostgresKyselyMigrator-CQ3aUoy_.cjs";
+import { IsolationLevel } from "./VitestTransactionIsolator-DHf2MxmC.cjs";
+import { VitestKyselyTransactionIsolator } from "./VitestKyselyTransactionIsolator-UE1J-UoP.cjs";
+import { Kysely, Transaction } from "kysely";
+import { TestAPI } from "vitest";
+
+//#region src/kysely.d.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');
+ * });
+ * ```
+ */
+declare function wrapVitestKyselyTransaction<Database>(api: TestAPI, db: Kysely<Database>, setup?: (trx: Transaction<Database>) => Promise<void>, level?: IsolationLevel): TestAPI<{
+  trx: Transaction<Database>;
+}>;
+//#endregion
+export { IsolationLevel, KyselyFactory, PostgresKyselyMigrator, VitestKyselyTransactionIsolator, wrapVitestKyselyTransaction };

package/dist/kysely.d.mts

@@ -0,0 +1,73 @@
+import "./faker-nN9Ki6fn.mjs";
+import "./Factory-DiZSNxC0.mjs";
+import { KyselyFactory } from "./KyselyFactory-B-zlLbov.mjs";
+import "./PostgresMigrator-BlvuQl7d.mjs";
+import { PostgresKyselyMigrator } from "./PostgresKyselyMigrator-_6yHZigp.mjs";
+import { IsolationLevel } from "./VitestTransactionIsolator-Xqyjlmw6.mjs";
+import { VitestKyselyTransactionIsolator } from "./VitestKyselyTransactionIsolator-ClCazkBO.mjs";
+import { Kysely, Transaction } from "kysely";
+import { TestAPI } from "vitest";
+
+//#region src/kysely.d.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');
+ * });
+ * ```
+ */
+declare function wrapVitestKyselyTransaction<Database>(api: TestAPI, db: Kysely<Database>, setup?: (trx: Transaction<Database>) => Promise<void>, level?: IsolationLevel): TestAPI<{
+  trx: Transaction<Database>;
+}>;
+//#endregion
+export { IsolationLevel, KyselyFactory, PostgresKyselyMigrator, VitestKyselyTransactionIsolator, wrapVitestKyselyTransaction };

package/dist/kysely.mjs

@@ -1,8 +1,8 @@
 import "./Factory-z2m01hMj.mjs";
 import "./faker-CxKkEeYi.mjs";
 import { KyselyFactory } from "./KyselyFactory-ELiHgHVv.mjs";
-import "./PostgresMigrator-BzqksJcW.mjs";
-import { PostgresKyselyMigrator } from "./PostgresKyselyMigrator-ChIpZFYB.mjs";
+import "./PostgresMigrator-DxPC_gGu.mjs";
+import { PostgresKyselyMigrator } from "./PostgresKyselyMigrator-Bdhl251C.mjs";
 import { IsolationLevel } from "./VitestTransactionIsolator-BWwK-ca6.mjs";
 import { VitestKyselyTransactionIsolator } from "./VitestKyselyTransactionIsolator-BKGT9nEG.mjs";
 import { wrapVitestKyselyTransaction } from "./kysely-Cx_1pZYc.mjs";

package/dist/objection.cjs

@@ -1,7 +1,8 @@
 require('./Factory-WMhTNZ9S.cjs');
-const require_ObjectionFactory = require('./ObjectionFactory-C47B03Ot.cjs');
-require('./PostgresMigrator-BtAWdLss.cjs');
-const require_PostgresObjectionMigrator = require('./PostgresObjectionMigrator-B88aTT0m.cjs');
+require('./faker-SMN4ira4.cjs');
+const require_ObjectionFactory = require('./ObjectionFactory-Wq80ypMM.cjs');
+require('./PostgresMigrator-DFcNdCvD.cjs');
+const require_PostgresObjectionMigrator = require('./PostgresObjectionMigrator-BG6ymgnt.cjs');
 const require_VitestTransactionIsolator = require('./VitestTransactionIsolator-CruLTRRi.cjs');
 const require_VitestObjectionTransactionIsolator = require('./VitestObjectionTransactionIsolator-DyqLp_in.cjs');
 const require_objection = require('./objection-CCD8fMLj.cjs');

package/dist/objection.d.cts

@@ -0,0 +1,88 @@
+import "./faker-DAiFK3T3.cjs";
+import "./Factory-B9LP1L18.cjs";
+import { ObjectionFactory } from "./ObjectionFactory-vME-wNlq.cjs";
+import "./PostgresMigrator-D5UkK1_K.cjs";
+import { PostgresObjectionMigrator } from "./PostgresObjectionMigrator-CZHHcCOv.cjs";
+import { IsolationLevel } from "./VitestTransactionIsolator-DHf2MxmC.cjs";
+import { VitestObjectionTransactionIsolator } from "./VitestObjectionTransactionIsolator-CO2nTi9r.cjs";
+import { Knex } from "knex";
+import { TestAPI } from "vitest";
+
+//#region src/objection.d.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 knex - 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);
+ * });
+ * ```
+ */
+declare function wrapVitestObjectionTransaction(api: TestAPI, knex: Knex, setup?: (trx: Knex.Transaction) => Promise<void>, level?: IsolationLevel): TestAPI<{
+  trx: Knex.Transaction<any, any[]>;
+}>;
+//#endregion
+export { IsolationLevel, ObjectionFactory, PostgresObjectionMigrator, VitestObjectionTransactionIsolator, wrapVitestObjectionTransaction };

package/dist/objection.d.mts

@@ -0,0 +1,88 @@
+import "./faker-nN9Ki6fn.mjs";
+import "./Factory-DiZSNxC0.mjs";
+import { ObjectionFactory } from "./ObjectionFactory-CJCpvwts.mjs";
+import "./PostgresMigrator-BlvuQl7d.mjs";
+import { PostgresObjectionMigrator } from "./PostgresObjectionMigrator-C69n7vzr.mjs";
+import { IsolationLevel } from "./VitestTransactionIsolator-Xqyjlmw6.mjs";
+import { VitestObjectionTransactionIsolator } from "./VitestObjectionTransactionIsolator-D264iuPy.mjs";
+import { TestAPI } from "vitest";
+import { Knex } from "knex";
+
+//#region src/objection.d.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 knex - 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);
+ * });
+ * ```
+ */
+declare function wrapVitestObjectionTransaction(api: TestAPI, knex: Knex, setup?: (trx: Knex.Transaction) => Promise<void>, level?: IsolationLevel): TestAPI<{
+  trx: Knex.Transaction<any, any[]>;
+}>;
+//#endregion
+export { IsolationLevel, ObjectionFactory, PostgresObjectionMigrator, VitestObjectionTransactionIsolator, wrapVitestObjectionTransaction };

package/dist/objection.mjs

@@ -1,7 +1,8 @@
 import "./Factory-z2m01hMj.mjs";
-import { ObjectionFactory } from "./ObjectionFactory-89p-FFEw.mjs";
-import "./PostgresMigrator-BzqksJcW.mjs";
-import { PostgresObjectionMigrator } from "./PostgresObjectionMigrator-DydSgYFv.mjs";
+import "./faker-CxKkEeYi.mjs";
+import { ObjectionFactory } from "./ObjectionFactory-aqM0dDW7.mjs";
+import "./PostgresMigrator-DxPC_gGu.mjs";
+import { PostgresObjectionMigrator } from "./PostgresObjectionMigrator-G4h5FLvU.mjs";
 import { IsolationLevel } from "./VitestTransactionIsolator-BWwK-ca6.mjs";
 import { VitestObjectionTransactionIsolator } from "./VitestObjectionTransactionIsolator-BPoLUFop.mjs";
 import { wrapVitestObjectionTransaction } from "./objection-lsMgM5gP.mjs";

package/package.json

@@ -1,21 +1,21 @@
 {
   "name": "@geekmidas/testkit",
-  "version": "0.0.9",
+  "version": "0.0.11",
   "private": false,
   "type": "module",
   "exports": {
     "./objection": {
-      "types": "./src/objection.ts",
+      "types": "./dist/objection.d.ts",
       "import": "./dist/objection.mjs",
       "require": "./dist/objection.cjs"
     },
     "./kysely": {
-      "types": "./src/kysely.ts",
+      "types": "./dist/kysely.ts",
       "import": "./dist/kysely.mjs",
       "require": "./dist/kysely.cjs"
     },
     "./faker": {
-      "types": "./src/faker.ts",
+      "types": "./dist/faker.d.ts",
       "import": "./dist/faker.mjs",
       "require": "./dist/faker.cjs"
     }
@@ -37,6 +37,6 @@
     "objection": "~3.1.5",
     "db-errors": "~0.2.3",
     "vitest": "~3.2.4",
-    "@geekmidas/envkit": "0.0.4"
+    "@geekmidas/envkit": "0.0.5"
   }
 }