@geekmidas/testkit 0.0.10 → 0.0.12

package/dist/VitestKyselyTransactionIsolator-ClCazkBO.d.mts

@@ -0,0 +1,56 @@
+import { IsolationLevel, VitestPostgresTransactionIsolator } from "./VitestTransactionIsolator-Xqyjlmw6.mjs";
+import { Kysely, Transaction } from "kysely";
+
+//#region src/VitestKyselyTransactionIsolator.d.ts
+
+/**
+ * Kysely-specific implementation of the Vitest transaction isolator.
+ * Provides automatic transaction rollback for test isolation using Kysely's transaction API.
+ * Each test runs within a database transaction that is rolled back after completion,
+ * ensuring a clean state between tests without the overhead of recreating data.
+ *
+ * @template Database - The database schema type
+ *
+ * @example
+ * ```typescript
+ * import { VitestKyselyTransactionIsolator } from '@geekmidas/testkit';
+ * import { db } from './database';
+ *
+ * // Create isolator instance
+ * const isolator = new VitestKyselyTransactionIsolator<Database>();
+ *
+ * // In your test setup
+ * beforeEach(async () => {
+ *   await isolator.start(db);
+ * });
+ *
+ * afterEach(async () => {
+ *   await isolator.rollback();
+ * });
+ *
+ * // Tests run in isolated transactions
+ * it('should create user', async () => {
+ *   const user = await db.insertInto('users')
+ *     .values({ name: 'Test User' })
+ *     .returningAll()
+ *     .executeTakeFirst();
+ *
+ *   expect(user).toBeDefined();
+ *   // This data will be rolled back after the test
+ * });
+ * ```
+ */
+declare class VitestKyselyTransactionIsolator<Database> extends VitestPostgresTransactionIsolator<Kysely<Database>, Transaction<Database>> {
+  /**
+   * Creates a Kysely transaction with the specified isolation level.
+   * Implements the abstract transact method from VitestPostgresTransactionIsolator.
+   *
+   * @param conn - The Kysely database connection
+   * @param level - The transaction isolation level
+   * @param fn - The function to execute within the transaction
+   * @returns Promise that resolves when the transaction completes
+   */
+  transact(conn: Kysely<Database>, level: IsolationLevel, fn: (trx: Transaction<Database>) => Promise<void>): Promise<void>;
+}
+//#endregion
+export { VitestKyselyTransactionIsolator };

package/dist/VitestKyselyTransactionIsolator-UE1J-UoP.d.cts

@@ -0,0 +1,56 @@
+import { IsolationLevel, VitestPostgresTransactionIsolator } from "./VitestTransactionIsolator-DHf2MxmC.cjs";
+import { Kysely, Transaction } from "kysely";
+
+//#region src/VitestKyselyTransactionIsolator.d.ts
+
+/**
+ * Kysely-specific implementation of the Vitest transaction isolator.
+ * Provides automatic transaction rollback for test isolation using Kysely's transaction API.
+ * Each test runs within a database transaction that is rolled back after completion,
+ * ensuring a clean state between tests without the overhead of recreating data.
+ *
+ * @template Database - The database schema type
+ *
+ * @example
+ * ```typescript
+ * import { VitestKyselyTransactionIsolator } from '@geekmidas/testkit';
+ * import { db } from './database';
+ *
+ * // Create isolator instance
+ * const isolator = new VitestKyselyTransactionIsolator<Database>();
+ *
+ * // In your test setup
+ * beforeEach(async () => {
+ *   await isolator.start(db);
+ * });
+ *
+ * afterEach(async () => {
+ *   await isolator.rollback();
+ * });
+ *
+ * // Tests run in isolated transactions
+ * it('should create user', async () => {
+ *   const user = await db.insertInto('users')
+ *     .values({ name: 'Test User' })
+ *     .returningAll()
+ *     .executeTakeFirst();
+ *
+ *   expect(user).toBeDefined();
+ *   // This data will be rolled back after the test
+ * });
+ * ```
+ */
+declare class VitestKyselyTransactionIsolator<Database> extends VitestPostgresTransactionIsolator<Kysely<Database>, Transaction<Database>> {
+  /**
+   * Creates a Kysely transaction with the specified isolation level.
+   * Implements the abstract transact method from VitestPostgresTransactionIsolator.
+   *
+   * @param conn - The Kysely database connection
+   * @param level - The transaction isolation level
+   * @param fn - The function to execute within the transaction
+   * @returns Promise that resolves when the transaction completes
+   */
+  transact(conn: Kysely<Database>, level: IsolationLevel, fn: (trx: Transaction<Database>) => Promise<void>): Promise<void>;
+}
+//#endregion
+export { VitestKyselyTransactionIsolator };

package/dist/VitestKyselyTransactionIsolator.d.cts

@@ -0,0 +1,3 @@
+import "./VitestTransactionIsolator-DHf2MxmC.cjs";
+import { VitestKyselyTransactionIsolator } from "./VitestKyselyTransactionIsolator-UE1J-UoP.cjs";
+export { VitestKyselyTransactionIsolator };

package/dist/VitestKyselyTransactionIsolator.d.mts

@@ -0,0 +1,3 @@
+import "./VitestTransactionIsolator-Xqyjlmw6.mjs";
+import { VitestKyselyTransactionIsolator } from "./VitestKyselyTransactionIsolator-ClCazkBO.mjs";
+export { VitestKyselyTransactionIsolator };

package/dist/VitestObjectionTransactionIsolator-CO2nTi9r.d.cts

@@ -0,0 +1,57 @@
+import { IsolationLevel, VitestPostgresTransactionIsolator } from "./VitestTransactionIsolator-DHf2MxmC.cjs";
+import { Knex } from "knex";
+
+//#region src/VitestObjectionTransactionIsolator.d.ts
+
+/**
+ * Objection.js-specific implementation of the Vitest transaction isolator.
+ * Provides automatic transaction rollback for test isolation using Objection.js and Knex transaction API.
+ * Each test runs within a database transaction that is rolled back after completion,
+ * ensuring a clean state between tests without the overhead of recreating data.
+ *
+ * @example
+ * ```typescript
+ * import { VitestObjectionTransactionIsolator } from '@geekmidas/testkit';
+ * import { knex } from './database';
+ * import { User } from './models';
+ * import { test } from 'vitest';
+ *
+ * // Create isolator instance
+ * const isolator = new VitestObjectionTransactionIsolator(test);
+ *
+ * // Use with wrapped test API
+ * const isolatedTest = isolator.wrapVitestWithTransaction(knex);
+ *
+ * isolatedTest('should create user', async ({ trx }) => {
+ *   const user = await User.query(trx)
+ *     .insert({ name: 'Test User' });
+ *
+ *   expect(user).toBeDefined();
+ *   // This data will be rolled back after the test
+ * });
+ * ```
+ */
+declare class VitestObjectionTransactionIsolator extends VitestPostgresTransactionIsolator<Knex, Knex.Transaction> {
+  /**
+   * Creates a Knex transaction with the specified isolation level.
+   * Implements the abstract transact method from VitestPostgresTransactionIsolator.
+   * This transaction can be used with Objection.js models via Model.query(trx).
+   *
+   * @param conn - The Knex database connection
+   * @param level - The transaction isolation level
+   * @param fn - The function to execute within the transaction
+   * @returns Promise that resolves when the transaction completes
+   *
+   * @example
+   * ```typescript
+   * await isolator.transact(knex, IsolationLevel.REPEATABLE_READ, async (trx) => {
+   *   // Use transaction with Objection models
+   *   await User.query(trx).insert({ name: 'Test' });
+   *   await Post.query(trx).where('userId', user.id).delete();
+   * });
+   * ```
+   */
+  transact(conn: Knex, level: IsolationLevel, fn: (trx: Knex.Transaction) => Promise<void>): Promise<void>;
+}
+//#endregion
+export { VitestObjectionTransactionIsolator };

package/dist/VitestObjectionTransactionIsolator-D264iuPy.d.mts

@@ -0,0 +1,57 @@
+import { IsolationLevel, VitestPostgresTransactionIsolator } from "./VitestTransactionIsolator-Xqyjlmw6.mjs";
+import { Knex } from "knex";
+
+//#region src/VitestObjectionTransactionIsolator.d.ts
+
+/**
+ * Objection.js-specific implementation of the Vitest transaction isolator.
+ * Provides automatic transaction rollback for test isolation using Objection.js and Knex transaction API.
+ * Each test runs within a database transaction that is rolled back after completion,
+ * ensuring a clean state between tests without the overhead of recreating data.
+ *
+ * @example
+ * ```typescript
+ * import { VitestObjectionTransactionIsolator } from '@geekmidas/testkit';
+ * import { knex } from './database';
+ * import { User } from './models';
+ * import { test } from 'vitest';
+ *
+ * // Create isolator instance
+ * const isolator = new VitestObjectionTransactionIsolator(test);
+ *
+ * // Use with wrapped test API
+ * const isolatedTest = isolator.wrapVitestWithTransaction(knex);
+ *
+ * isolatedTest('should create user', async ({ trx }) => {
+ *   const user = await User.query(trx)
+ *     .insert({ name: 'Test User' });
+ *
+ *   expect(user).toBeDefined();
+ *   // This data will be rolled back after the test
+ * });
+ * ```
+ */
+declare class VitestObjectionTransactionIsolator extends VitestPostgresTransactionIsolator<Knex, Knex.Transaction> {
+  /**
+   * Creates a Knex transaction with the specified isolation level.
+   * Implements the abstract transact method from VitestPostgresTransactionIsolator.
+   * This transaction can be used with Objection.js models via Model.query(trx).
+   *
+   * @param conn - The Knex database connection
+   * @param level - The transaction isolation level
+   * @param fn - The function to execute within the transaction
+   * @returns Promise that resolves when the transaction completes
+   *
+   * @example
+   * ```typescript
+   * await isolator.transact(knex, IsolationLevel.REPEATABLE_READ, async (trx) => {
+   *   // Use transaction with Objection models
+   *   await User.query(trx).insert({ name: 'Test' });
+   *   await Post.query(trx).where('userId', user.id).delete();
+   * });
+   * ```
+   */
+  transact(conn: Knex, level: IsolationLevel, fn: (trx: Knex.Transaction) => Promise<void>): Promise<void>;
+}
+//#endregion
+export { VitestObjectionTransactionIsolator };

package/dist/VitestObjectionTransactionIsolator.d.cts

@@ -0,0 +1,3 @@
+import "./VitestTransactionIsolator-DHf2MxmC.cjs";
+import { VitestObjectionTransactionIsolator } from "./VitestObjectionTransactionIsolator-CO2nTi9r.cjs";
+export { VitestObjectionTransactionIsolator };

package/dist/VitestObjectionTransactionIsolator.d.mts

@@ -0,0 +1,3 @@
+import "./VitestTransactionIsolator-Xqyjlmw6.mjs";
+import { VitestObjectionTransactionIsolator } from "./VitestObjectionTransactionIsolator-D264iuPy.mjs";
+export { VitestObjectionTransactionIsolator };

package/dist/VitestTransactionIsolator-DHf2MxmC.d.cts

@@ -0,0 +1,118 @@
+import { TestAPI } from "vitest";
+
+//#region src/VitestTransactionIsolator.d.ts
+
+/**
+ * Type definition for test fixtures that provide transaction access.
+ * Used with Vitest's test.extend() API to inject transactions into tests.
+ *
+ * @template Transaction - The transaction type specific to the database driver
+ */
+interface DatabaseFixtures<Transaction> {
+  /**
+   * The database transaction available to the test.
+   * All database operations should use this transaction to ensure proper rollback.
+   */
+  trx: Transaction;
+}
+/**
+ * PostgreSQL transaction isolation levels.
+ * Controls the visibility of concurrent transactions.
+ *
+ * @see https://www.postgresql.org/docs/current/transaction-iso.html
+ */
+declare enum IsolationLevel {
+  /**
+   * Lowest isolation level. Allows dirty reads.
+   * Not recommended for testing.
+   */
+  READ_UNCOMMITTED = "READ UNCOMMITTED",
+  /**
+   * Default PostgreSQL isolation level.
+   * Prevents dirty reads but allows non-repeatable reads.
+   */
+  READ_COMMITTED = "READ COMMITTED",
+  /**
+   * Prevents dirty reads and non-repeatable reads.
+   * Recommended for most test scenarios.
+   */
+  REPEATABLE_READ = "REPEATABLE READ",
+  /**
+   * Highest isolation level. Prevents all phenomena.
+   * May cause performance overhead in tests.
+   */
+  SERIALIZABLE = "SERIALIZABLE",
+}
+/**
+ * Abstract base class for implementing database transaction isolation in Vitest tests.
+ * Provides automatic transaction rollback after each test to maintain test isolation.
+ * Subclasses must implement the transact() method for their specific database driver.
+ *
+ * @template Connection - The database connection type
+ * @template Transaction - The transaction type
+ *
+ * @example
+ * ```typescript
+ * // Implement for your database driver
+ * class MyDatabaseIsolator extends VitestPostgresTransactionIsolator<MyDB, MyTx> {
+ *   async transact(conn: MyDB, level: IsolationLevel, fn: (tx: MyTx) => Promise<void>) {
+ *     await conn.transaction(level, fn);
+ *   }
+ * }
+ *
+ * // Use in tests
+ * const isolator = new MyDatabaseIsolator(test);
+ * const isolatedTest = isolator.wrapVitestWithTransaction(db);
+ *
+ * isolatedTest('should create user', async ({ trx }) => {
+ *   await trx.insert('users', { name: 'Test' });
+ *   // Data is automatically rolled back after test
+ * });
+ * ```
+ */
+declare abstract class VitestPostgresTransactionIsolator<Connection, Transaction> {
+  private readonly api;
+  /**
+   * Abstract method to create a transaction with the specified isolation level.
+   * Must be implemented by subclasses for specific database drivers.
+   *
+   * @param conn - The database connection
+   * @param isolationLevel - The transaction isolation level
+   * @param fn - The function to execute within the transaction
+   * @returns Promise that resolves when the transaction completes
+   */
+  abstract transact(conn: Connection, isolationLevel: IsolationLevel, fn: (trx: Transaction) => Promise<void>): Promise<void>;
+  /**
+   * Creates a new VitestPostgresTransactionIsolator instance.
+   *
+   * @param api - The Vitest test API (usually the `test` export from vitest)
+   */
+  constructor(api: TestAPI);
+  /**
+   * 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)
+   * @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' });
+   * });
+   *
+   * isolatedTest('test with transaction', async ({ trx }) => {
+   *   const user = await trx.insert('users', { name: 'Test' });
+   *   expect(user).toBeDefined();
+   * });
+   * ```
+   */
+  wrapVitestWithTransaction(conn: Connection, setup?: (trx: Transaction) => Promise<void>, level?: IsolationLevel): TestAPI<{
+    trx: Transaction;
+  }>;
+}
+//#endregion
+export { DatabaseFixtures, IsolationLevel, VitestPostgresTransactionIsolator };

package/dist/VitestTransactionIsolator-Xqyjlmw6.d.mts

@@ -0,0 +1,118 @@
+import { TestAPI } from "vitest";
+
+//#region src/VitestTransactionIsolator.d.ts
+
+/**
+ * Type definition for test fixtures that provide transaction access.
+ * Used with Vitest's test.extend() API to inject transactions into tests.
+ *
+ * @template Transaction - The transaction type specific to the database driver
+ */
+interface DatabaseFixtures<Transaction> {
+  /**
+   * The database transaction available to the test.
+   * All database operations should use this transaction to ensure proper rollback.
+   */
+  trx: Transaction;
+}
+/**
+ * PostgreSQL transaction isolation levels.
+ * Controls the visibility of concurrent transactions.
+ *
+ * @see https://www.postgresql.org/docs/current/transaction-iso.html
+ */
+declare enum IsolationLevel {
+  /**
+   * Lowest isolation level. Allows dirty reads.
+   * Not recommended for testing.
+   */
+  READ_UNCOMMITTED = "READ UNCOMMITTED",
+  /**
+   * Default PostgreSQL isolation level.
+   * Prevents dirty reads but allows non-repeatable reads.
+   */
+  READ_COMMITTED = "READ COMMITTED",
+  /**
+   * Prevents dirty reads and non-repeatable reads.
+   * Recommended for most test scenarios.
+   */
+  REPEATABLE_READ = "REPEATABLE READ",
+  /**
+   * Highest isolation level. Prevents all phenomena.
+   * May cause performance overhead in tests.
+   */
+  SERIALIZABLE = "SERIALIZABLE",
+}
+/**
+ * Abstract base class for implementing database transaction isolation in Vitest tests.
+ * Provides automatic transaction rollback after each test to maintain test isolation.
+ * Subclasses must implement the transact() method for their specific database driver.
+ *
+ * @template Connection - The database connection type
+ * @template Transaction - The transaction type
+ *
+ * @example
+ * ```typescript
+ * // Implement for your database driver
+ * class MyDatabaseIsolator extends VitestPostgresTransactionIsolator<MyDB, MyTx> {
+ *   async transact(conn: MyDB, level: IsolationLevel, fn: (tx: MyTx) => Promise<void>) {
+ *     await conn.transaction(level, fn);
+ *   }
+ * }
+ *
+ * // Use in tests
+ * const isolator = new MyDatabaseIsolator(test);
+ * const isolatedTest = isolator.wrapVitestWithTransaction(db);
+ *
+ * isolatedTest('should create user', async ({ trx }) => {
+ *   await trx.insert('users', { name: 'Test' });
+ *   // Data is automatically rolled back after test
+ * });
+ * ```
+ */
+declare abstract class VitestPostgresTransactionIsolator<Connection, Transaction> {
+  private readonly api;
+  /**
+   * Abstract method to create a transaction with the specified isolation level.
+   * Must be implemented by subclasses for specific database drivers.
+   *
+   * @param conn - The database connection
+   * @param isolationLevel - The transaction isolation level
+   * @param fn - The function to execute within the transaction
+   * @returns Promise that resolves when the transaction completes
+   */
+  abstract transact(conn: Connection, isolationLevel: IsolationLevel, fn: (trx: Transaction) => Promise<void>): Promise<void>;
+  /**
+   * Creates a new VitestPostgresTransactionIsolator instance.
+   *
+   * @param api - The Vitest test API (usually the `test` export from vitest)
+   */
+  constructor(api: TestAPI);
+  /**
+   * 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)
+   * @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' });
+   * });
+   *
+   * isolatedTest('test with transaction', async ({ trx }) => {
+   *   const user = await trx.insert('users', { name: 'Test' });
+   *   expect(user).toBeDefined();
+   * });
+   * ```
+   */
+  wrapVitestWithTransaction(conn: Connection, setup?: (trx: Transaction) => Promise<void>, level?: IsolationLevel): TestAPI<{
+    trx: Transaction;
+  }>;
+}
+//#endregion
+export { DatabaseFixtures, IsolationLevel, VitestPostgresTransactionIsolator };

package/dist/VitestTransactionIsolator.d.cts

@@ -0,0 +1,2 @@
+import { DatabaseFixtures, IsolationLevel, VitestPostgresTransactionIsolator } from "./VitestTransactionIsolator-DHf2MxmC.cjs";
+export { DatabaseFixtures, IsolationLevel, VitestPostgresTransactionIsolator };

package/dist/VitestTransactionIsolator.d.mts

@@ -0,0 +1,2 @@
+import { DatabaseFixtures, IsolationLevel, VitestPostgresTransactionIsolator } from "./VitestTransactionIsolator-Xqyjlmw6.mjs";
+export { DatabaseFixtures, IsolationLevel, VitestPostgresTransactionIsolator };

package/dist/__tests__/Factory.spec.d.cts

@@ -0,0 +1 @@
+export { };

package/dist/__tests__/Factory.spec.d.mts

@@ -0,0 +1 @@
+export { };

package/dist/__tests__/KyselyFactory.spec.cjs

@@ -1,7 +1,7 @@
 const require_chunk = require('../chunk-CUT6urMc.cjs');
 require('../Factory-WMhTNZ9S.cjs');
-require('../faker-SMN4ira4.cjs');
-const require_KyselyFactory = require('../KyselyFactory-Bdq1s1Go.cjs');
+require('../faker-B14IEMIN.cjs');
+const require_KyselyFactory = require('../KyselyFactory-CXtfmMfK.cjs');
 require('../PostgresMigrator-DFcNdCvD.cjs');
 require('../PostgresKyselyMigrator-CfytARcA.cjs');
 require('../VitestTransactionIsolator-CruLTRRi.cjs');

package/dist/__tests__/KyselyFactory.spec.d.cts

@@ -0,0 +1 @@
+export { };

package/dist/__tests__/KyselyFactory.spec.d.mts

@@ -0,0 +1 @@
+export { };

package/dist/__tests__/KyselyFactory.spec.mjs

@@ -1,6 +1,6 @@
 import "../Factory-z2m01hMj.mjs";
-import "../faker-CxKkEeYi.mjs";
-import { KyselyFactory } from "../KyselyFactory-ELiHgHVv.mjs";
+import "../faker-BGKYFoCT.mjs";
+import { KyselyFactory } from "../KyselyFactory-C3Bc3p4L.mjs";
 import "../PostgresMigrator-DxPC_gGu.mjs";
 import "../PostgresKyselyMigrator-Bdhl251C.mjs";
 import "../VitestTransactionIsolator-BWwK-ca6.mjs";

package/dist/__tests__/ObjectionFactory.spec.cjs

@@ -1,6 +1,7 @@
 const require_chunk = require('../chunk-CUT6urMc.cjs');
 require('../Factory-WMhTNZ9S.cjs');
-const require_ObjectionFactory = require('../ObjectionFactory-C47B03Ot.cjs');
+const require_faker = require('../faker-B14IEMIN.cjs');
+const require_ObjectionFactory = require('../ObjectionFactory-DxIxJagq.cjs');
 const require_helpers = require('../helpers-CNMBePuj.cjs');
 const vitest = require_chunk.__toESM(require("vitest"));
 const objection = require_chunk.__toESM(require("objection"));
@@ -286,6 +287,121 @@ vitest.describe.skip("ObjectionFactory", () => {
 			(0, vitest.expect)(result).toBe(seedFn);
 		});
 	});
+	(0, vitest.describe)("createBuilder static method", () => {
+		(0, vitest.it)("should create a builder function with auto-insert", async () => {
+			const userBuilder = require_ObjectionFactory.ObjectionFactory.createBuilder(User, (attrs, factory$1, db$1, faker$1) => ({
+				name: faker$1.person.fullName(),
+				email: faker$1.internet.email(),
+				role: "user",
+				createdAt: /* @__PURE__ */ new Date(),
+				updatedAt: /* @__PURE__ */ new Date(),
+				...attrs
+			}));
+			const builders = { user: userBuilder };
+			factory = new require_ObjectionFactory.ObjectionFactory(builders, {}, trx);
+			const result = await factory.insert("user", { name: "Test User" });
+			(0, vitest.expect)(result).toBeInstanceOf(User);
+			(0, vitest.expect)(result.name).toBe("Test User");
+			(0, vitest.expect)(result.email).toMatch(/@/);
+			(0, vitest.expect)(result.id).toBeDefined();
+		});
+		(0, vitest.it)("should create a builder function without auto-insert", async () => {
+			const userBuilder = require_ObjectionFactory.ObjectionFactory.createBuilder(User, (attrs) => ({
+				name: "No Insert User",
+				email: "noinsert@example.com",
+				role: "user",
+				createdAt: /* @__PURE__ */ new Date(),
+				updatedAt: /* @__PURE__ */ new Date(),
+				...attrs
+			}), false);
+			const builders = { user: userBuilder };
+			factory = new require_ObjectionFactory.ObjectionFactory(builders, {}, trx);
+			const result = await factory.insert("user");
+			(0, vitest.expect)(result).toBeInstanceOf(User);
+			(0, vitest.expect)(result.name).toBe("No Insert User");
+			(0, vitest.expect)(result.id).toBeDefined();
+		});
+		(0, vitest.it)("should pass all parameters to the item function", async () => {
+			let capturedFactory;
+			let capturedDb;
+			let capturedFaker;
+			const userBuilder = require_ObjectionFactory.ObjectionFactory.createBuilder(User, (attrs, factory$1, db$1, fakerInstance) => {
+				capturedFactory = factory$1;
+				capturedDb = db$1;
+				capturedFaker = fakerInstance;
+				return {
+					name: "Test User",
+					email: "test@example.com",
+					role: "user",
+					createdAt: /* @__PURE__ */ new Date(),
+					updatedAt: /* @__PURE__ */ new Date(),
+					...attrs
+				};
+			});
+			const builders = { user: userBuilder };
+			factory = new require_ObjectionFactory.ObjectionFactory(builders, {}, trx);
+			await factory.insert("user");
+			(0, vitest.expect)(capturedFactory).toBe(factory);
+			(0, vitest.expect)(capturedDb).toBe(trx);
+			(0, vitest.expect)(capturedFaker).toBe(require_faker.faker);
+		});
+		(0, vitest.it)("should handle async item functions", async () => {
+			const userBuilder = require_ObjectionFactory.ObjectionFactory.createBuilder(User, async (attrs, factory$1, db$1, faker$1) => {
+				await new Promise((resolve) => setTimeout(resolve, 10));
+				return {
+					name: "Async User",
+					email: faker$1.internet.email(),
+					role: "user",
+					createdAt: /* @__PURE__ */ new Date(),
+					updatedAt: /* @__PURE__ */ new Date(),
+					...attrs
+				};
+			});
+			const builders = { user: userBuilder };
+			factory = new require_ObjectionFactory.ObjectionFactory(builders, {}, trx);
+			const result = await factory.insert("user");
+			(0, vitest.expect)(result).toBeInstanceOf(User);
+			(0, vitest.expect)(result.name).toBe("Async User");
+			(0, vitest.expect)(result.id).toBeDefined();
+		});
+		(0, vitest.it)("should work without item function", async () => {
+			const userBuilder = require_ObjectionFactory.ObjectionFactory.createBuilder(User);
+			const builders = { user: userBuilder };
+			factory = new require_ObjectionFactory.ObjectionFactory(builders, {}, trx);
+			const attrs = {
+				name: "Manual User",
+				email: "manual@example.com",
+				role: "user",
+				createdAt: /* @__PURE__ */ new Date(),
+				updatedAt: /* @__PURE__ */ new Date()
+			};
+			const result = await factory.insert("user", attrs);
+			(0, vitest.expect)(result).toBeInstanceOf(User);
+			(0, vitest.expect)(result.name).toBe("Manual User");
+			(0, vitest.expect)(result.email).toBe("manual@example.com");
+			(0, vitest.expect)(result.id).toBeDefined();
+		});
+		(0, vitest.it)("should allow overriding default values", async () => {
+			const userBuilder = require_ObjectionFactory.ObjectionFactory.createBuilder(User, (attrs, factory$1, db$1, faker$1) => ({
+				name: "Default Name",
+				email: "default@example.com",
+				role: "user",
+				createdAt: /* @__PURE__ */ new Date(),
+				updatedAt: /* @__PURE__ */ new Date(),
+				...attrs
+			}));
+			const builders = { user: userBuilder };
+			factory = new require_ObjectionFactory.ObjectionFactory(builders, {}, trx);
+			const result = await factory.insert("user", {
+				name: "Override Name",
+				email: "override@example.com"
+			});
+			(0, vitest.expect)(result).toBeInstanceOf(User);
+			(0, vitest.expect)(result.name).toBe("Override Name");
+			(0, vitest.expect)(result.email).toBe("override@example.com");
+			(0, vitest.expect)(result.role).toBe("user");
+		});
+	});
 	(0, vitest.describe)("error handling", () => {
 		(0, vitest.it)("should handle builder errors gracefully", async () => {
 			const userBuilder = async (attrs, factory$1, db$1) => {

package/dist/__tests__/ObjectionFactory.spec.d.cts

@@ -0,0 +1 @@
+export { };

package/dist/__tests__/ObjectionFactory.spec.d.mts

@@ -0,0 +1 @@
+export { };