@geekmidas/testkit 0.0.16 → 0.1.0

package/dist/better-auth.mjs

@@ -0,0 +1,241 @@
+import { createAdapterFactory } from "better-auth/adapters";
+
+//#region src/better-auth.ts
+var MemoryStore = class {
+	constructor(initialData, data = /* @__PURE__ */ new Map()) {
+		this.data = data;
+		if (initialData) for (const [model, records] of Object.entries(initialData)) {
+			const modelData = /* @__PURE__ */ new Map();
+			for (const record of records) modelData.set(record.id, { ...record });
+			this.data.set(model, modelData);
+		}
+	}
+	getModel(modelName) {
+		if (!this.data.has(modelName)) this.data.set(modelName, /* @__PURE__ */ new Map());
+		return this.data.get(modelName);
+	}
+	clear() {
+		this.data.clear();
+	}
+	getAllData() {
+		const result = {};
+		for (const [model, records] of this.data.entries()) result[model] = Array.from(records.values());
+		return result;
+	}
+};
+function matchesWhere(record, where) {
+	if (!where || where.length === 0) return true;
+	let result = null;
+	for (const condition of where) {
+		const { field, value, operator = "eq", connector = "AND" } = condition;
+		const recordValue = record[field];
+		let matches = false;
+		switch (operator) {
+			case "eq":
+				matches = recordValue === value;
+				break;
+			case "ne":
+				matches = recordValue !== value;
+				break;
+			case "lt":
+				matches = value != null && recordValue < value;
+				break;
+			case "lte":
+				matches = value != null && recordValue <= value;
+				break;
+			case "gt":
+				matches = value != null && recordValue > value;
+				break;
+			case "gte":
+				matches = value != null && recordValue >= value;
+				break;
+			case "in":
+				matches = Array.isArray(value) && value.includes(recordValue);
+				break;
+			case "not_in":
+				matches = Array.isArray(value) && !value.includes(recordValue);
+				break;
+			case "contains":
+				matches = typeof recordValue === "string" && typeof value === "string" && recordValue.includes(value);
+				break;
+			case "starts_with":
+				matches = typeof recordValue === "string" && typeof value === "string" && recordValue.startsWith(value);
+				break;
+			case "ends_with":
+				matches = typeof recordValue === "string" && typeof value === "string" && recordValue.endsWith(value);
+				break;
+			default: matches = recordValue === value;
+		}
+		if (result === null) result = matches;
+		else if (connector === "OR") result = result || matches;
+		else result = result && matches;
+	}
+	return result ?? true;
+}
+function applySorting(records, sortBy) {
+	if (!sortBy) return records;
+	const { field, direction } = sortBy;
+	return records.sort((a, b) => {
+		const aVal = a[field];
+		const bVal = b[field];
+		if (aVal === bVal) return 0;
+		if (aVal == null) return direction === "asc" ? -1 : 1;
+		if (bVal == null) return direction === "asc" ? 1 : -1;
+		const comparison = aVal < bVal ? -1 : 1;
+		return direction === "asc" ? comparison : -comparison;
+	});
+}
+const memoryAdapter = (config = {}, store = /* @__PURE__ */ new Map()) => {
+	const storeInstance = new MemoryStore(config.initialData, store);
+	const adapterInstance = createAdapterFactory({
+		config: {
+			adapterId: "memory-adapter",
+			adapterName: "Memory Adapter",
+			usePlural: config.usePlural ?? false,
+			debugLogs: config.debugLogs ?? false,
+			supportsJSON: true,
+			supportsDates: true,
+			supportsBooleans: true,
+			supportsNumericIds: false
+		},
+		adapter: ({ debugLog, transformInput, transformOutput, getModelName, transformWhereClause }) => ({
+			create: async ({ data, model, select }) => {
+				debugLog("CREATE", {
+					model,
+					data
+				});
+				const modelName = getModelName(model);
+				const modelData = storeInstance.getModel(modelName);
+				const transformedData = await transformInput(data, model, "create");
+				if (!transformedData.id) transformedData.id = crypto.randomUUID();
+				modelData.set(transformedData.id, {
+					...transformedData,
+					...data
+				});
+				if (data.email_address) modelData.set(transformedData.id, {
+					...transformedData,
+					email: data.email_address
+				});
+				const created = modelData.get(transformedData.id);
+				const out = await transformOutput(created, model, select);
+				return out;
+			},
+			findOne: async ({ where, model, select }) => {
+				debugLog("FIND_ONE", {
+					model,
+					where
+				});
+				const modelName = getModelName(model);
+				const modelData = storeInstance.getModel(modelName);
+				const transformedWhere = transformWhereClause({
+					model,
+					where
+				});
+				for (const record of modelData.values()) if (matchesWhere(record, transformedWhere)) {
+					const t = await transformOutput(record, model, select);
+					return t;
+				}
+				return null;
+			},
+			findMany: async ({ where, model, limit, offset, sortBy }) => {
+				debugLog("FIND_MANY", {
+					model,
+					where
+				});
+				const modelName = getModelName(model);
+				const modelData = storeInstance.getModel(modelName);
+				const transformedWhere = transformWhereClause({
+					model,
+					where
+				});
+				let results = Array.from(modelData.values()).filter((record) => matchesWhere(record, transformedWhere));
+				if (sortBy) results = applySorting(results, sortBy);
+				if (offset) results = results.slice(offset);
+				if (limit) results = results.slice(0, limit);
+				return Promise.all(results.map((record) => transformOutput(record, model)));
+			},
+			update: async ({ where, update, model }) => {
+				debugLog("UPDATE", {
+					model,
+					where
+				});
+				const modelName = getModelName(model);
+				const modelData = storeInstance.getModel(modelName);
+				const transformedWhere = transformWhereClause({
+					model,
+					where
+				});
+				for (const [id, record] of modelData.entries()) if (matchesWhere(record, transformedWhere)) {
+					const transformedData = await transformInput(update, model, "update");
+					const updated = {
+						...record,
+						...transformedData
+					};
+					modelData.set(id, updated);
+					return transformOutput(updated, model);
+				}
+				return null;
+			},
+			updateMany: async ({ where, update, model }) => {
+				debugLog("UPDATE_MANY", {
+					model,
+					where
+				});
+				const modelName = getModelName(model);
+				const modelData = storeInstance.getModel(modelName);
+				const transformedWhere = transformWhereClause({
+					model,
+					where
+				});
+				let count = 0;
+				const transformedData = await transformInput(update, model, "update");
+				for (const [id, record] of modelData.entries()) if (matchesWhere(record, transformedWhere)) {
+					modelData.set(id, {
+						...record,
+						...transformedData
+					});
+					count++;
+				}
+				return count;
+			},
+			delete: async ({ where, model }) => {
+				debugLog("DELETE", {
+					model,
+					where
+				});
+				const modelName = getModelName(model);
+				const modelData = storeInstance.getModel(modelName);
+				for (const [id, record] of modelData.entries()) if (matchesWhere(record, where)) {
+					modelData.delete(id);
+					return;
+				}
+			},
+			deleteMany: async ({ where, model }) => {
+				debugLog("DELETE_MANY", {
+					model,
+					where
+				});
+				const modelName = getModelName(model);
+				const modelData = storeInstance.getModel(modelName);
+				const toDelete = [];
+				for (const [id, record] of modelData.entries()) if (matchesWhere(record, where)) toDelete.push(id);
+				toDelete.forEach((id) => modelData.delete(id));
+				return toDelete.length;
+			},
+			count: async ({ where, model }) => {
+				const modelName = getModelName(model);
+				const modelData = storeInstance.getModel(modelName);
+				return Array.from(modelData.values()).filter((record) => matchesWhere(record, where)).length;
+			}
+		})
+	});
+	return Object.assign(adapterInstance, {
+		clear: () => store.clear(),
+		getAllData: () => storeInstance.getAllData(),
+		getStore: () => store
+	});
+};
+
+//#endregion
+export { memoryAdapter };
+//# sourceMappingURL=better-auth.mjs.map

package/dist/better-auth.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"better-auth.mjs","names":["initialData?: Record<string, any[]>","data: Map<string, any>","modelName: string","result: Record<string, any[]>","record: any","where?: Where[]","result: boolean | null","records: any[]","sortBy?: SortBy","config: MemoryAdapterConfig","toDelete: string[]"],"sources":["../src/better-auth.ts"],"sourcesContent":["import {\n  type DBAdapterDebugLogOption,\n  type Where,\n  createAdapterFactory,\n} from 'better-auth/adapters';\n\ninterface MemoryAdapterConfig {\n  debugLogs?: DBAdapterDebugLogOption;\n  usePlural?: boolean;\n  initialData?: Record<string, any[]>;\n}\n\nclass MemoryStore {\n  constructor(\n    initialData?: Record<string, any[]>,\n    private readonly data: Map<string, any> = new Map(),\n  ) {\n    if (initialData) {\n      for (const [model, records] of Object.entries(initialData)) {\n        const modelData = new Map();\n        for (const record of records) {\n          modelData.set(record.id, { ...record });\n        }\n        this.data.set(model, modelData);\n      }\n    }\n  }\n\n  getModel(modelName: string): Map<string, any> {\n    if (!this.data.has(modelName)) {\n      this.data.set(modelName, new Map());\n    }\n    return this.data.get(modelName)!;\n  }\n\n  clear() {\n    this.data.clear();\n  }\n\n  getAllData() {\n    const result: Record<string, any[]> = {};\n    for (const [model, records] of this.data.entries()) {\n      result[model] = Array.from(records.values());\n    }\n    return result;\n  }\n}\n\nfunction matchesWhere(record: any, where?: Where[]): boolean {\n  if (!where || where.length === 0) return true;\n\n  let result: boolean | null = null;\n\n  for (const condition of where) {\n    const { field, value, operator = 'eq', connector = 'AND' } = condition;\n    const recordValue = record[field];\n\n    let matches = false;\n\n    switch (operator) {\n      case 'eq':\n        matches = recordValue === value;\n        break;\n      case 'ne':\n        matches = recordValue !== value;\n        break;\n      case 'lt':\n        matches = value != null && recordValue < value;\n        break;\n      case 'lte':\n        matches = value != null && recordValue <= value;\n        break;\n      case 'gt':\n        matches = value != null && recordValue > value;\n        break;\n      case 'gte':\n        matches = value != null && recordValue >= value;\n        break;\n      case 'in':\n        matches =\n          Array.isArray(value) && (value as unknown[]).includes(recordValue);\n        break;\n      case 'not_in':\n        matches =\n          Array.isArray(value) && !(value as unknown[]).includes(recordValue);\n        break;\n      case 'contains':\n        matches =\n          typeof recordValue === 'string' &&\n          typeof value === 'string' &&\n          recordValue.includes(value);\n        break;\n      case 'starts_with':\n        matches =\n          typeof recordValue === 'string' &&\n          typeof value === 'string' &&\n          recordValue.startsWith(value);\n        break;\n      case 'ends_with':\n        matches =\n          typeof recordValue === 'string' &&\n          typeof value === 'string' &&\n          recordValue.endsWith(value);\n        break;\n      default:\n        matches = recordValue === value;\n    }\n\n    // Apply connector logic\n    if (result === null) {\n      result = matches;\n    } else if (connector === 'OR') {\n      result = result || matches;\n    } else {\n      // Default: AND\n      result = result && matches;\n    }\n  }\n\n  return result ?? true;\n}\ntype SortBy = {\n  field: string;\n  direction: 'asc' | 'desc';\n};\n\nfunction applySorting(records: any[], sortBy?: SortBy): any[] {\n  if (!sortBy) return records;\n\n  const { field, direction } = sortBy;\n\n  return records.sort((a, b) => {\n    const aVal = a[field];\n    const bVal = b[field];\n\n    if (aVal === bVal) return 0;\n    if (aVal == null) return direction === 'asc' ? -1 : 1;\n    if (bVal == null) return direction === 'asc' ? 1 : -1;\n\n    const comparison = aVal < bVal ? -1 : 1;\n    return direction === 'asc' ? comparison : -comparison;\n  });\n}\n\nexport const memoryAdapter = (\n  config: MemoryAdapterConfig = {},\n  store = new Map(),\n) => {\n  const storeInstance = new MemoryStore(config.initialData, store);\n\n  const adapterInstance = createAdapterFactory({\n    config: {\n      adapterId: 'memory-adapter',\n      adapterName: 'Memory Adapter',\n      usePlural: config.usePlural ?? false,\n      debugLogs: config.debugLogs ?? false,\n      supportsJSON: true,\n      supportsDates: true,\n      supportsBooleans: true,\n      supportsNumericIds: false,\n    },\n\n    adapter: ({\n      debugLog,\n      transformInput,\n      transformOutput,\n      getModelName,\n      transformWhereClause,\n    }) => ({\n      create: async ({ data, model, select }) => {\n        debugLog('CREATE', { model, data });\n        const modelName = getModelName(model);\n        const modelData = storeInstance.getModel(modelName);\n\n        const transformedData = await transformInput(data, model, 'create');\n\n        if (!transformedData.id) {\n          transformedData.id = crypto.randomUUID();\n        }\n\n        modelData.set(transformedData.id, { ...transformedData, ...data });\n\n        if (data.email_address) {\n          modelData.set(transformedData.id, {\n            ...transformedData,\n            email: data.email_address,\n          });\n        }\n        const created = modelData.get(transformedData.id);\n\n        const out = (await transformOutput(created, model, select)) as any;\n\n        return out;\n      },\n\n      findOne: async ({ where, model, select }) => {\n        debugLog('FIND_ONE', { model, where });\n        const modelName = getModelName(model);\n        const modelData = storeInstance.getModel(modelName);\n        const transformedWhere = transformWhereClause({ model, where });\n\n        for (const record of modelData.values()) {\n          if (matchesWhere(record, transformedWhere)) {\n            const t = (await transformOutput(record, model, select)) as any;\n\n            return t;\n          }\n        }\n        return null;\n      },\n\n      findMany: async ({ where, model, limit, offset, sortBy }) => {\n        debugLog('FIND_MANY', { model, where });\n\n        const modelName = getModelName(model);\n        const modelData = storeInstance.getModel(modelName);\n        const transformedWhere = transformWhereClause({ model, where });\n\n        let results = Array.from(modelData.values()).filter((record) =>\n          matchesWhere(record, transformedWhere),\n        );\n\n        if (sortBy) {\n          results = applySorting(results, sortBy);\n        }\n\n        if (offset) {\n          results = results.slice(offset);\n        }\n        if (limit) {\n          results = results.slice(0, limit);\n        }\n\n        return Promise.all(\n          results.map((record) => transformOutput(record, model)),\n        ) as any;\n      },\n\n      update: async ({ where, update, model }) => {\n        debugLog('UPDATE', { model, where });\n\n        const modelName = getModelName(model);\n        const modelData = storeInstance.getModel(modelName);\n        const transformedWhere = transformWhereClause({ model, where });\n\n        for (const [id, record] of modelData.entries()) {\n          if (matchesWhere(record, transformedWhere)) {\n            const transformedData = await transformInput(\n              update as any,\n              model,\n              'update',\n            );\n            const updated = { ...record, ...transformedData };\n            modelData.set(id, updated);\n            return transformOutput(updated, model) as any;\n          }\n        }\n        return null;\n      },\n\n      updateMany: async ({ where, update, model }) => {\n        debugLog('UPDATE_MANY', { model, where });\n        const modelName = getModelName(model);\n        const modelData = storeInstance.getModel(modelName);\n        const transformedWhere = transformWhereClause({ model, where });\n\n        let count = 0;\n        const transformedData = await transformInput(update, model, 'update');\n\n        for (const [id, record] of modelData.entries()) {\n          if (matchesWhere(record, transformedWhere)) {\n            modelData.set(id, { ...record, ...transformedData });\n            count++;\n          }\n        }\n        return count;\n      },\n\n      delete: async ({ where, model }) => {\n        debugLog('DELETE', { model, where });\n        const modelName = getModelName(model);\n        const modelData = storeInstance.getModel(modelName);\n\n        for (const [id, record] of modelData.entries()) {\n          if (matchesWhere(record, where)) {\n            modelData.delete(id);\n            return;\n          }\n        }\n      },\n\n      deleteMany: async ({ where, model }) => {\n        debugLog('DELETE_MANY', { model, where });\n        const modelName = getModelName(model);\n        const modelData = storeInstance.getModel(modelName);\n\n        const toDelete: string[] = [];\n        for (const [id, record] of modelData.entries()) {\n          if (matchesWhere(record, where)) {\n            toDelete.push(id);\n          }\n        }\n\n        toDelete.forEach((id) => modelData.delete(id));\n        return toDelete.length;\n      },\n\n      count: async ({ where, model }) => {\n        const modelName = getModelName(model);\n        const modelData = storeInstance.getModel(modelName);\n\n        return Array.from(modelData.values()).filter((record) =>\n          matchesWhere(record, where),\n        ).length;\n      },\n    }),\n  });\n\n  // Add utility methods to the adapter\n  return Object.assign(adapterInstance, {\n    clear: () => store.clear(),\n    getAllData: () => storeInstance.getAllData(),\n    getStore: () => store,\n  });\n};\n"],"mappings":"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"}

package/dist/{directory-B4oYx02C.d.mts → directory-BXavAeJZ.d.mts}

@@ -1,7 +1,7 @@
-import * as vitest0 from "vitest";
+import * as vitest6 from "vitest";
 
 //#region src/os/directory.d.ts
-declare const itWithDir: vitest0.TestAPI<{
+declare const itWithDir: vitest6.TestAPI<{
   dir: string;
 }>;
 interface DirectoryFixtures {
@@ -9,4 +9,4 @@ interface DirectoryFixtures {
 }
 //#endregion
 export { DirectoryFixtures, itWithDir };
-//# sourceMappingURL=directory-B4oYx02C.d.mts.map
+//# sourceMappingURL=directory-BXavAeJZ.d.mts.map

package/dist/{directory-BUcnztHI.d.cts → directory-DlkPEzL4.d.cts}

@@ -1,7 +1,7 @@
-import * as vitest0 from "vitest";
+import * as vitest6 from "vitest";
 
 //#region src/os/directory.d.ts
-declare const itWithDir: vitest0.TestAPI<{
+declare const itWithDir: vitest6.TestAPI<{
   dir: string;
 }>;
 interface DirectoryFixtures {
@@ -9,4 +9,4 @@ interface DirectoryFixtures {
 }
 //#endregion
 export { DirectoryFixtures, itWithDir };
-//# sourceMappingURL=directory-BUcnztHI.d.cts.map
+//# sourceMappingURL=directory-DlkPEzL4.d.cts.map

package/dist/kysely.cjs

@@ -1,10 +1,10 @@
 require('./Factory-WMhTNZ9S.cjs');
-require('./faker-B14IEMIN.cjs');
-const require_KyselyFactory = require('./KyselyFactory-Cf0o2YxO.cjs');
+const require_faker = require('./faker-B14IEMIN.cjs');
+const require_KyselyFactory = require('./KyselyFactory-DaaCykWP.cjs');
 require('./PostgresMigrator-DFcNdCvD.cjs');
 const require_PostgresKyselyMigrator = require('./PostgresKyselyMigrator-CfytARcA.cjs');
-const require_VitestTransactionIsolator = require('./VitestTransactionIsolator-BQ5FpLtC.cjs');
-const require_VitestKyselyTransactionIsolator = require('./VitestKyselyTransactionIsolator-Cst3vFjb.cjs');
+const require_VitestTransactionIsolator = require('./VitestTransactionIsolator-BKIrj3Uy.cjs');
+const require_VitestKyselyTransactionIsolator = require('./VitestKyselyTransactionIsolator-DX_VPKS-.cjs');
 
 //#region src/kysely.ts
 /**
@@ -67,11 +67,65 @@ function wrapVitestKyselyTransaction(api, connection, setup, level = require_Vit
 	const wrapper = new require_VitestKyselyTransactionIsolator.VitestKyselyTransactionIsolator(api);
 	return wrapper.wrapVitestWithTransaction(connection, setup, level);
 }
+/**
+* Extends a Kysely transaction-wrapped test with additional fixtures.
+* Each fixture receives the transaction and can create dependencies like factories or repositories.
+*
+* @template Database - The database schema type
+* @template Extended - The type of additional fixtures to provide
+* @param wrappedTest - The base wrapped test from wrapVitestKyselyTransaction
+* @param fixtures - Object mapping fixture names to creator functions
+* @returns An extended test API with both trx and the additional fixtures
+*
+* @example
+* ```typescript
+* import { test } from 'vitest';
+* import { wrapVitestKyselyTransaction, extendWithFixtures, KyselyFactory } from '@geekmidas/testkit/kysely';
+*
+* // Define your builders
+* const builders = {
+*   user: KyselyFactory.createBuilder<DB, 'users'>('users', ({ faker }) => ({
+*     name: faker.person.fullName(),
+*     email: faker.internet.email(),
+*   })),
+* };
+*
+* // Create base wrapped test
+* const baseTest = wrapVitestKyselyTransaction<DB>(test, db, createTestTables);
+*
+* // Extend with fixtures - each fixture receives the transaction
+* const it = extendWithFixtures<DB, { factory: KyselyFactory<DB, typeof builders, {}> }>(
+*   baseTest,
+*   {
+*     factory: (trx) => new KyselyFactory(builders, {}, trx),
+*   }
+* );
+*
+* // Use in tests - both trx and factory are available
+* it('should create user with factory', async ({ trx, factory }) => {
+*   const user = await factory.insert('user', { name: 'Test User' });
+*   expect(user.id).toBeDefined();
+*
+*   // Verify in database
+*   const found = await trx
+*     .selectFrom('users')
+*     .where('id', '=', user.id)
+*     .selectAll()
+*     .executeTakeFirst();
+*   expect(found?.name).toBe('Test User');
+* });
+* ```
+*/
+function extendWithFixtures$1(wrappedTest, fixtures) {
+	return require_VitestTransactionIsolator.extendWithFixtures(wrappedTest, fixtures);
+}
 
 //#endregion
 exports.IsolationLevel = require_VitestTransactionIsolator.IsolationLevel;
 exports.KyselyFactory = require_KyselyFactory.KyselyFactory;
 exports.PostgresKyselyMigrator = require_PostgresKyselyMigrator.PostgresKyselyMigrator;
 exports.VitestKyselyTransactionIsolator = require_VitestKyselyTransactionIsolator.VitestKyselyTransactionIsolator;
+exports.extendWithFixtures = extendWithFixtures$1;
+exports.faker = require_faker.faker;
 exports.wrapVitestKyselyTransaction = wrapVitestKyselyTransaction;
 //# sourceMappingURL=kysely.cjs.map

package/dist/kysely.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"kysely.cjs","names":["api: TestAPI","connection: DatabaseConnection<Kysely<Database>>","setup?: (trx: Transaction<Database>) => Promise<void>","level: IsolationLevel","IsolationLevel","VitestKyselyTransactionIsolator"],"sources":["../src/kysely.ts"],"sourcesContent":["import type { Kysely, Transaction } from 'kysely';\nimport type { TestAPI } from 'vitest';\nimport { VitestKyselyTransactionIsolator } from './VitestKyselyTransactionIsolator';\nimport {\n  type DatabaseConnection,\n  IsolationLevel,\n} from './VitestTransactionIsolator';\n\n/**\n * Kysely-specific exports for test utilities.\n * Provides factories, migrators, and transaction isolators for Kysely ORM.\n */\n\nexport { KyselyFactory } from './KyselyFactory';\nexport { PostgresKyselyMigrator } from './PostgresKyselyMigrator';\nexport { VitestKyselyTransactionIsolator } from './VitestKyselyTransactionIsolator';\nexport { IsolationLevel } from './VitestTransactionIsolator';\n\n/**\n * Creates a wrapped Vitest test API with automatic transaction rollback for Kysely.\n * Each test runs in an isolated database transaction that is rolled back after completion.\n * This ensures tests don't affect each other's data and run faster than truncating tables.\n *\n * @template Database - The database schema type\n * @param api - The Vitest test API (usually `test` from vitest)\n * @param db - The Kysely database instance\n * @param setup - Optional setup function to run before each test in the transaction\n * @param level - Transaction isolation level (defaults to REPEATABLE_READ)\n * @returns A wrapped test API that provides transaction isolation\n *\n * @example\n * ```typescript\n * import { test } from 'vitest';\n * import { wrapVitestKyselyTransaction } from '@geekmidas/testkit/kysely';\n * import { db } from './database';\n *\n * // Create isolated test with automatic rollback\n * const isolatedTest = wrapVitestKyselyTransaction(test, db);\n *\n * // Use in tests - each test gets its own transaction\n * isolatedTest('should create user', async ({ trx }) => {\n *   const user = await trx\n *     .insertInto('users')\n *     .values({ name: 'Test User', email: 'test@example.com' })\n *     .returningAll()\n *     .executeTakeFirst();\n *\n *   expect(user).toBeDefined();\n *   // User is automatically rolled back after test\n * });\n *\n * // With setup function for common test data\n * const testWithSetup = wrapVitestKyselyTransaction(\n *   test,\n *   db,\n *   async (trx) => {\n *     // Create common test data\n *     await trx.insertInto('settings')\n *       .values({ key: 'test_mode', value: 'true' })\n *       .execute();\n *   }\n * );\n *\n * testWithSetup('should have test settings', async ({ trx }) => {\n *   const setting = await trx\n *     .selectFrom('settings')\n *     .where('key', '=', 'test_mode')\n *     .selectAll()\n *     .executeTakeFirst();\n *\n *   expect(setting?.value).toBe('true');\n * });\n * ```\n */\nexport function wrapVitestKyselyTransaction<Database>(\n  api: TestAPI,\n  connection: DatabaseConnection<Kysely<Database>>,\n  setup?: (trx: Transaction<Database>) => Promise<void>,\n  level: IsolationLevel = IsolationLevel.REPEATABLE_READ,\n) {\n  const wrapper = new VitestKyselyTransactionIsolator<Database>(api);\n\n  return wrapper.wrapVitestWithTransaction(connection, setup, level);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA0EA,SAAgB,4BACdA,KACAC,YACAC,OACAC,QAAwBC,iDAAe,iBACvC;CACA,MAAM,UAAU,IAAIC,wEAA0C;AAE9D,QAAO,QAAQ,0BAA0B,YAAY,OAAO,MAAM;AACnE"}
+{"version":3,"file":"kysely.cjs","names":["api: TestAPI","connection: DatabaseConnection<Kysely<Database>>","setup?: (trx: Transaction<Database>) => Promise<void>","level: IsolationLevel","IsolationLevel","VitestKyselyTransactionIsolator","extendWithFixtures","wrappedTest: T","fixtures: FixtureCreators<Transaction<Database>, Extended>"],"sources":["../src/kysely.ts"],"sourcesContent":["import type { Kysely, Transaction } from 'kysely';\nimport type { TestAPI } from 'vitest';\nimport { VitestKyselyTransactionIsolator } from './VitestKyselyTransactionIsolator';\nimport {\n  type DatabaseConnection,\n  type FixtureCreators,\n  IsolationLevel,\n  extendWithFixtures as baseExtendWithFixtures,\n} from './VitestTransactionIsolator';\n\n/**\n * Kysely-specific exports for test utilities.\n * Provides factories, migrators, and transaction isolators for Kysely ORM.\n */\n\nexport { KyselyFactory } from './KyselyFactory';\nexport { PostgresKyselyMigrator } from './PostgresKyselyMigrator';\nexport { VitestKyselyTransactionIsolator } from './VitestKyselyTransactionIsolator';\nexport { IsolationLevel } from './VitestTransactionIsolator';\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 Kysely.\n * Each test runs in an isolated database transaction that is rolled back after completion.\n * This ensures tests don't affect each other's data and run faster than truncating tables.\n *\n * @template Database - The database schema type\n * @param api - The Vitest test API (usually `test` from vitest)\n * @param db - The Kysely database instance\n * @param setup - Optional setup function to run before each test in the transaction\n * @param level - Transaction isolation level (defaults to REPEATABLE_READ)\n * @returns A wrapped test API that provides transaction isolation\n *\n * @example\n * ```typescript\n * import { test } from 'vitest';\n * import { wrapVitestKyselyTransaction } from '@geekmidas/testkit/kysely';\n * import { db } from './database';\n *\n * // Create isolated test with automatic rollback\n * const isolatedTest = wrapVitestKyselyTransaction(test, db);\n *\n * // Use in tests - each test gets its own transaction\n * isolatedTest('should create user', async ({ trx }) => {\n *   const user = await trx\n *     .insertInto('users')\n *     .values({ name: 'Test User', email: 'test@example.com' })\n *     .returningAll()\n *     .executeTakeFirst();\n *\n *   expect(user).toBeDefined();\n *   // User is automatically rolled back after test\n * });\n *\n * // With setup function for common test data\n * const testWithSetup = wrapVitestKyselyTransaction(\n *   test,\n *   db,\n *   async (trx) => {\n *     // Create common test data\n *     await trx.insertInto('settings')\n *       .values({ key: 'test_mode', value: 'true' })\n *       .execute();\n *   }\n * );\n *\n * testWithSetup('should have test settings', async ({ trx }) => {\n *   const setting = await trx\n *     .selectFrom('settings')\n *     .where('key', '=', 'test_mode')\n *     .selectAll()\n *     .executeTakeFirst();\n *\n *   expect(setting?.value).toBe('true');\n * });\n * ```\n */\nexport function wrapVitestKyselyTransaction<Database>(\n  api: TestAPI,\n  connection: DatabaseConnection<Kysely<Database>>,\n  setup?: (trx: Transaction<Database>) => Promise<void>,\n  level: IsolationLevel = IsolationLevel.REPEATABLE_READ,\n) {\n  const wrapper = new VitestKyselyTransactionIsolator<Database>(api);\n\n  return wrapper.wrapVitestWithTransaction(connection, setup, level);\n}\n\n/**\n * Extends a Kysely transaction-wrapped test with additional fixtures.\n * Each fixture receives the transaction and can create dependencies like factories or repositories.\n *\n * @template Database - The database schema type\n * @template Extended - The type of additional fixtures to provide\n * @param wrappedTest - The base wrapped test from wrapVitestKyselyTransaction\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 { wrapVitestKyselyTransaction, extendWithFixtures, KyselyFactory } from '@geekmidas/testkit/kysely';\n *\n * // Define your builders\n * const builders = {\n *   user: KyselyFactory.createBuilder<DB, 'users'>('users', ({ faker }) => ({\n *     name: faker.person.fullName(),\n *     email: faker.internet.email(),\n *   })),\n * };\n *\n * // Create base wrapped test\n * const baseTest = wrapVitestKyselyTransaction<DB>(test, db, createTestTables);\n *\n * // Extend with fixtures - each fixture receives the transaction\n * const it = extendWithFixtures<DB, { factory: KyselyFactory<DB, typeof builders, {}> }>(\n *   baseTest,\n *   {\n *     factory: (trx) => new KyselyFactory(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 trx\n *     .selectFrom('users')\n *     .where('id', '=', user.id)\n *     .selectAll()\n *     .executeTakeFirst();\n *   expect(found?.name).toBe('Test User');\n * });\n * ```\n */\nexport function extendWithFixtures<\n  Database,\n  Extended extends Record<string, unknown>,\n  T extends ReturnType<TestAPI['extend']> = ReturnType<TestAPI['extend']>,\n>(wrappedTest: T, fixtures: FixtureCreators<Transaction<Database>, Extended>) {\n  return baseExtendWithFixtures<Transaction<Database>, Extended, T>(\n    wrappedTest,\n    fixtures,\n  );\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgFA,SAAgB,4BACdA,KACAC,YACAC,OACAC,QAAwBC,iDAAe,iBACvC;CACA,MAAM,UAAU,IAAIC,wEAA0C;AAE9D,QAAO,QAAQ,0BAA0B,YAAY,OAAO,MAAM;AACnE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAmDD,SAAgBC,qBAIdC,aAAgBC,UAA4D;AAC5E,QAAO,qDACL,aACA,SACD;AACF"}

package/dist/kysely.d.cts

@@ -1,10 +1,10 @@
-import "./faker-Cg76aFNO.cjs";
+import { FakerFactory, faker } from "./faker-Cg76aFNO.cjs";
 import "./Factory-BZ8uMoXl.cjs";
-import { KyselyFactory } from "./KyselyFactory-DRQ83r0o.cjs";
+import { KyselyFactory } from "./KyselyFactory-BFygzOlO.cjs";
 import "./PostgresMigrator-D5UkK1_K.cjs";
 import { PostgresKyselyMigrator } from "./PostgresKyselyMigrator-CQ3aUoy_.cjs";
-import { DatabaseConnection, IsolationLevel } from "./VitestTransactionIsolator-DdLNODZg.cjs";
-import { VitestKyselyTransactionIsolator } from "./VitestKyselyTransactionIsolator-DYUYVEh9.cjs";
+import { DatabaseConnection, DatabaseFixtures, FixtureCreators, IsolationLevel } from "./VitestTransactionIsolator-CyG_i_Nj.cjs";
+import { VitestKyselyTransactionIsolator } from "./VitestKyselyTransactionIsolator-4HOeLQ0d.cjs";
 import { Kysely, Transaction } from "kysely";
 import { TestAPI } from "vitest";
 
@@ -69,6 +69,59 @@ import { TestAPI } from "vitest";
 declare function wrapVitestKyselyTransaction<Database>(api: TestAPI, connection: DatabaseConnection<Kysely<Database>>, setup?: (trx: Transaction<Database>) => Promise<void>, level?: IsolationLevel): TestAPI<{
   trx: Transaction<Database>;
 }>;
+/**
+ * Extends a Kysely transaction-wrapped test with additional fixtures.
+ * Each fixture receives the transaction and can create dependencies like factories or repositories.
+ *
+ * @template Database - The database schema type
+ * @template Extended - The type of additional fixtures to provide
+ * @param wrappedTest - The base wrapped test from wrapVitestKyselyTransaction
+ * @param fixtures - Object mapping fixture names to creator functions
+ * @returns An extended test API with both trx and the additional fixtures
+ *
+ * @example
+ * ```typescript
+ * import { test } from 'vitest';
+ * import { wrapVitestKyselyTransaction, extendWithFixtures, KyselyFactory } from '@geekmidas/testkit/kysely';
+ *
+ * // Define your builders
+ * const builders = {
+ *   user: KyselyFactory.createBuilder<DB, 'users'>('users', ({ faker }) => ({
+ *     name: faker.person.fullName(),
+ *     email: faker.internet.email(),
+ *   })),
+ * };
+ *
+ * // Create base wrapped test
+ * const baseTest = wrapVitestKyselyTransaction<DB>(test, db, createTestTables);
+ *
+ * // Extend with fixtures - each fixture receives the transaction
+ * const it = extendWithFixtures<DB, { factory: KyselyFactory<DB, typeof builders, {}> }>(
+ *   baseTest,
+ *   {
+ *     factory: (trx) => new KyselyFactory(builders, {}, trx),
+ *   }
+ * );
+ *
+ * // Use in tests - both trx and factory are available
+ * it('should create user with factory', async ({ trx, factory }) => {
+ *   const user = await factory.insert('user', { name: 'Test User' });
+ *   expect(user.id).toBeDefined();
+ *
+ *   // Verify in database
+ *   const found = await trx
+ *     .selectFrom('users')
+ *     .where('id', '=', user.id)
+ *     .selectAll()
+ *     .executeTakeFirst();
+ *   expect(found?.name).toBe('Test User');
+ * });
+ * ```
+ */
+declare function extendWithFixtures<Database, Extended extends Record<string, unknown>, T extends ReturnType<TestAPI['extend']> = ReturnType<TestAPI['extend']>>(wrappedTest: T, fixtures: FixtureCreators<Transaction<Database>, Extended>): T & {
+  <C extends object>(name: string, fn: (context: DatabaseFixtures<Transaction<Database>, object> & Extended & C) => Promise<void>): void;
+  <C extends object>(name: string, options: object, fn: (context: DatabaseFixtures<Transaction<Database>, object> & Extended & C) => Promise<void>): void;
+};
 //#endregion
-export { IsolationLevel, KyselyFactory, PostgresKyselyMigrator, VitestKyselyTransactionIsolator, wrapVitestKyselyTransaction };
+export { FakerFactory, FixtureCreators, IsolationLevel, KyselyFactory, PostgresKyselyMigrator, VitestKyselyTransactionIsolator, extendWithFixtures, faker, wrapVitestKyselyTransaction };
 //# sourceMappingURL=kysely.d.cts.map

package/dist/kysely.d.mts

@@ -1,10 +1,10 @@
-import "./faker-DHh7xs4u.mjs";
+import { FakerFactory, faker } from "./faker-DHh7xs4u.mjs";
 import "./Factory-Cmr3s3-s.mjs";
-import { KyselyFactory } from "./KyselyFactory-Cx3sezwH.mjs";
+import { KyselyFactory } from "./KyselyFactory-BTdygZ-i.mjs";
 import "./PostgresMigrator-DQaRxoaY.mjs";
 import { PostgresKyselyMigrator } from "./PostgresKyselyMigrator-CIx3AFSR.mjs";
-import { DatabaseConnection, IsolationLevel } from "./VitestTransactionIsolator-CsfJBxcb.mjs";
-import { VitestKyselyTransactionIsolator } from "./VitestKyselyTransactionIsolator-COCVfvfr.mjs";
+import { DatabaseConnection, DatabaseFixtures, FixtureCreators, IsolationLevel } from "./VitestTransactionIsolator-DWDbnITQ.mjs";
+import { VitestKyselyTransactionIsolator } from "./VitestKyselyTransactionIsolator-DnyZMaA-.mjs";
 import { Kysely, Transaction } from "kysely";
 import { TestAPI } from "vitest";
 
@@ -69,6 +69,59 @@ import { TestAPI } from "vitest";
 declare function wrapVitestKyselyTransaction<Database>(api: TestAPI, connection: DatabaseConnection<Kysely<Database>>, setup?: (trx: Transaction<Database>) => Promise<void>, level?: IsolationLevel): TestAPI<{
   trx: Transaction<Database>;
 }>;
+/**
+ * Extends a Kysely transaction-wrapped test with additional fixtures.
+ * Each fixture receives the transaction and can create dependencies like factories or repositories.
+ *
+ * @template Database - The database schema type
+ * @template Extended - The type of additional fixtures to provide
+ * @param wrappedTest - The base wrapped test from wrapVitestKyselyTransaction
+ * @param fixtures - Object mapping fixture names to creator functions
+ * @returns An extended test API with both trx and the additional fixtures
+ *
+ * @example
+ * ```typescript
+ * import { test } from 'vitest';
+ * import { wrapVitestKyselyTransaction, extendWithFixtures, KyselyFactory } from '@geekmidas/testkit/kysely';
+ *
+ * // Define your builders
+ * const builders = {
+ *   user: KyselyFactory.createBuilder<DB, 'users'>('users', ({ faker }) => ({
+ *     name: faker.person.fullName(),
+ *     email: faker.internet.email(),
+ *   })),
+ * };
+ *
+ * // Create base wrapped test
+ * const baseTest = wrapVitestKyselyTransaction<DB>(test, db, createTestTables);
+ *
+ * // Extend with fixtures - each fixture receives the transaction
+ * const it = extendWithFixtures<DB, { factory: KyselyFactory<DB, typeof builders, {}> }>(
+ *   baseTest,
+ *   {
+ *     factory: (trx) => new KyselyFactory(builders, {}, trx),
+ *   }
+ * );
+ *
+ * // Use in tests - both trx and factory are available
+ * it('should create user with factory', async ({ trx, factory }) => {
+ *   const user = await factory.insert('user', { name: 'Test User' });
+ *   expect(user.id).toBeDefined();
+ *
+ *   // Verify in database
+ *   const found = await trx
+ *     .selectFrom('users')
+ *     .where('id', '=', user.id)
+ *     .selectAll()
+ *     .executeTakeFirst();
+ *   expect(found?.name).toBe('Test User');
+ * });
+ * ```
+ */
+declare function extendWithFixtures<Database, Extended extends Record<string, unknown>, T extends ReturnType<TestAPI['extend']> = ReturnType<TestAPI['extend']>>(wrappedTest: T, fixtures: FixtureCreators<Transaction<Database>, Extended>): T & {
+  <C extends object>(name: string, fn: (context: DatabaseFixtures<Transaction<Database>, object> & Extended & C) => Promise<void>): void;
+  <C extends object>(name: string, options: object, fn: (context: DatabaseFixtures<Transaction<Database>, object> & Extended & C) => Promise<void>): void;
+};
 //#endregion
-export { IsolationLevel, KyselyFactory, PostgresKyselyMigrator, VitestKyselyTransactionIsolator, wrapVitestKyselyTransaction };
+export { FakerFactory, FixtureCreators, IsolationLevel, KyselyFactory, PostgresKyselyMigrator, VitestKyselyTransactionIsolator, extendWithFixtures, faker, wrapVitestKyselyTransaction };
 //# sourceMappingURL=kysely.d.mts.map

package/dist/kysely.mjs

@@ -1,10 +1,10 @@
 import "./Factory-z2m01hMj.mjs";
-import "./faker-BGKYFoCT.mjs";
-import { KyselyFactory } from "./KyselyFactory-BcYkC0t2.mjs";
+import { faker } from "./faker-BGKYFoCT.mjs";
+import { KyselyFactory } from "./KyselyFactory-CXY5gJk2.mjs";
 import "./PostgresMigrator-DbuJGAVy.mjs";
 import { PostgresKyselyMigrator } from "./PostgresKyselyMigrator-upT-hmrz.mjs";
-import { IsolationLevel } from "./VitestTransactionIsolator-CskiiJbW.mjs";
-import { VitestKyselyTransactionIsolator } from "./VitestKyselyTransactionIsolator-BxjlD1YM.mjs";
+import { IsolationLevel, extendWithFixtures } from "./VitestTransactionIsolator-BIaMs4c2.mjs";
+import { VitestKyselyTransactionIsolator } from "./VitestKyselyTransactionIsolator-XDL3ngs_.mjs";
 
 //#region src/kysely.ts
 /**
@@ -67,7 +67,59 @@ function wrapVitestKyselyTransaction(api, connection, setup, level = IsolationLe
 	const wrapper = new VitestKyselyTransactionIsolator(api);
 	return wrapper.wrapVitestWithTransaction(connection, setup, level);
 }
+/**
+* Extends a Kysely transaction-wrapped test with additional fixtures.
+* Each fixture receives the transaction and can create dependencies like factories or repositories.
+*
+* @template Database - The database schema type
+* @template Extended - The type of additional fixtures to provide
+* @param wrappedTest - The base wrapped test from wrapVitestKyselyTransaction
+* @param fixtures - Object mapping fixture names to creator functions
+* @returns An extended test API with both trx and the additional fixtures
+*
+* @example
+* ```typescript
+* import { test } from 'vitest';
+* import { wrapVitestKyselyTransaction, extendWithFixtures, KyselyFactory } from '@geekmidas/testkit/kysely';
+*
+* // Define your builders
+* const builders = {
+*   user: KyselyFactory.createBuilder<DB, 'users'>('users', ({ faker }) => ({
+*     name: faker.person.fullName(),
+*     email: faker.internet.email(),
+*   })),
+* };
+*
+* // Create base wrapped test
+* const baseTest = wrapVitestKyselyTransaction<DB>(test, db, createTestTables);
+*
+* // Extend with fixtures - each fixture receives the transaction
+* const it = extendWithFixtures<DB, { factory: KyselyFactory<DB, typeof builders, {}> }>(
+*   baseTest,
+*   {
+*     factory: (trx) => new KyselyFactory(builders, {}, trx),
+*   }
+* );
+*
+* // Use in tests - both trx and factory are available
+* it('should create user with factory', async ({ trx, factory }) => {
+*   const user = await factory.insert('user', { name: 'Test User' });
+*   expect(user.id).toBeDefined();
+*
+*   // Verify in database
+*   const found = await trx
+*     .selectFrom('users')
+*     .where('id', '=', user.id)
+*     .selectAll()
+*     .executeTakeFirst();
+*   expect(found?.name).toBe('Test User');
+* });
+* ```
+*/
+function extendWithFixtures$1(wrappedTest, fixtures) {
+	return extendWithFixtures(wrappedTest, fixtures);
+}
 
 //#endregion
-export { IsolationLevel, KyselyFactory, PostgresKyselyMigrator, VitestKyselyTransactionIsolator, wrapVitestKyselyTransaction };
+export { IsolationLevel, KyselyFactory, PostgresKyselyMigrator, VitestKyselyTransactionIsolator, extendWithFixtures$1 as extendWithFixtures, faker, wrapVitestKyselyTransaction };
 //# sourceMappingURL=kysely.mjs.map