@geekmidas/testkit 0.0.10 → 0.0.11

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.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/objection.cjs

@@ -1,5 +1,6 @@
 require('./Factory-WMhTNZ9S.cjs');
-const require_ObjectionFactory = require('./ObjectionFactory-C47B03Ot.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');

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,5 +1,6 @@
 import "./Factory-z2m01hMj.mjs";
-import { ObjectionFactory } from "./ObjectionFactory-89p-FFEw.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";

package/package.json

@@ -1,21 +1,21 @@
 {
   "name": "@geekmidas/testkit",
-  "version": "0.0.10",
+  "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"
   }
 }