@geekmidas/testkit 10.0.0-alpha.4 → 10.0.0-alpha.41

package/dist/initScript.cjs

@@ -1,7 +1,8 @@
-const require_chunk = require('./chunk-CUT6urMc.cjs');
-const pg = require_chunk.__toESM(require("pg"));
-const node_fs = require_chunk.__toESM(require("node:fs"));
-
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_rolldown_runtime = require("./rolldown-runtime-VH7oDXx4.cjs");
+let pg = require("pg");
+pg = require_rolldown_runtime.__toESM(pg, 1);
+let node_fs = require("node:fs");
 //#region src/initScript.ts
 const { Client } = pg.default;
 /**
@@ -18,13 +19,14 @@ function parseInitScript(content, env) {
 	const lines = content.split("\n");
 	let inHeredoc = false;
 	let currentBlock = [];
-	for (const line of lines) if (inHeredoc) if (/^\s*EOSQL\s*$/.test(line)) {
-		const sql = substituteEnvVars(currentBlock.join("\n"), env);
-		blocks.push(sql);
-		currentBlock = [];
-		inHeredoc = false;
-	} else currentBlock.push(line);
-	else if (line.includes("<<-EOSQL") || line.includes("<< EOSQL") || line.includes("<<EOSQL")) {
+	for (const line of lines) if (inHeredoc) {
+		if (/^\s*EOSQL\s*$/.test(line)) {
+			const sql = substituteEnvVars(currentBlock.join("\n"), env);
+			blocks.push(sql);
+			currentBlock = [];
+			inHeredoc = false;
+		} else currentBlock.push(line);
+	} else if (line.includes("<<-EOSQL") || line.includes("<< EOSQL") || line.includes("<<EOSQL")) {
 		inHeredoc = true;
 		currentBlock = [];
 	}
@@ -70,9 +72,7 @@ function substituteEnvVars(sql, env) {
 * ```
 */
 async function runInitScript(scriptPath, databaseUrl, env) {
-	const content = (0, node_fs.readFileSync)(scriptPath, "utf-8");
-	const resolvedEnv = env ?? { ...process.env };
-	const blocks = parseInitScript(content, resolvedEnv);
+	const blocks = parseInitScript((0, node_fs.readFileSync)(scriptPath, "utf-8"), env ?? { ...process.env });
 	if (blocks.length === 0) return;
 	const url = new URL(databaseUrl);
 	const client = new Client({
@@ -89,8 +89,8 @@ async function runInitScript(scriptPath, databaseUrl, env) {
 		await client.end();
 	}
 }
-
 //#endregion
 exports.parseInitScript = parseInitScript;
 exports.runInitScript = runInitScript;
+
 //# sourceMappingURL=initScript.cjs.map

package/dist/initScript.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"initScript.cjs","names":["content: string","env: Record<string, string>","blocks: string[]","currentBlock: string[]","sql: string","scriptPath: string","databaseUrl: string","env?: Record<string, string>"],"sources":["../src/initScript.ts"],"sourcesContent":["import { readFileSync } from 'node:fs';\nimport pg from 'pg';\n\nconst { Client } = pg;\n\n/**\n * Parse a shell init script (like docker/postgres/init.sh) and extract\n * SQL blocks from heredoc sections (<<-EOSQL ... EOSQL).\n *\n * @param content - The shell script content\n * @param env - Environment variables to substitute ($VAR_NAME references)\n * @returns Array of SQL strings ready to execute\n * @internal Exported for testing\n */\nexport function parseInitScript(\n\tcontent: string,\n\tenv: Record<string, string>,\n): string[] {\n\tconst blocks: string[] = [];\n\tconst lines = content.split('\\n');\n\tlet inHeredoc = false;\n\tlet currentBlock: string[] = [];\n\n\tfor (const line of lines) {\n\t\tif (inHeredoc) {\n\t\t\t// Check for heredoc terminator (EOSQL at start of line, with optional leading whitespace)\n\t\t\tif (/^\\s*EOSQL\\s*$/.test(line)) {\n\t\t\t\tconst sql = substituteEnvVars(currentBlock.join('\\n'), env);\n\t\t\t\tblocks.push(sql);\n\t\t\t\tcurrentBlock = [];\n\t\t\t\tinHeredoc = false;\n\t\t\t} else {\n\t\t\t\tcurrentBlock.push(line);\n\t\t\t}\n\t\t} else if (\n\t\t\tline.includes('<<-EOSQL') ||\n\t\t\tline.includes('<< EOSQL') ||\n\t\t\tline.includes('<<EOSQL')\n\t\t) {\n\t\t\tinHeredoc = true;\n\t\t\tcurrentBlock = [];\n\t\t}\n\t}\n\n\treturn blocks;\n}\n\n/**\n * Replace shell variable references ($VAR_NAME and ${VAR_NAME})\n * with values from the provided env object.\n */\nfunction substituteEnvVars(sql: string, env: Record<string, string>): string {\n\t// Replace ${VAR_NAME} syntax\n\tlet result = sql.replace(/\\$\\{(\\w+)\\}/g, (_, name) => env[name] ?? '');\n\t// Replace $VAR_NAME syntax (word boundary after)\n\tresult = result.replace(/\\$(\\w+)/g, (_, name) => env[name] ?? '');\n\t// Unescape bash-escaped dollar signs (\\$ → $) AFTER variable substitution\n\t// This handles PL/pgSQL dollar-quoting like DO \\$\\$ ... END \\$\\$;\n\tresult = result.replace(/\\\\\\$/g, '$');\n\treturn result;\n}\n\n/**\n * Read a postgres init script, parse out the SQL blocks,\n * substitute environment variables, and execute against a database.\n *\n * This is intended to run `docker/postgres/init.sh` against a test database\n * so that per-app users and schemas are created (matching what Docker does\n * on first volume initialization).\n *\n * Uses `CREATE ... IF NOT EXISTS` and `DO $$ ... END $$` wrappers where\n * needed so the script is idempotent.\n *\n * @param scriptPath - Path to the init.sh file\n * @param databaseUrl - PostgreSQL connection URL (should point to the test database)\n *\n * @example\n * ```typescript\n * // In your globalSetup.ts\n * import { runInitScript } from '@geekmidas/testkit/postgres';\n * import { Credentials } from '@geekmidas/envkit/credentials';\n *\n * const cleanup = await migrator.start();\n *\n * // Create per-app users in the test database\n * await runInitScript('docker/postgres/init.sh', Credentials.DATABASE_URL, {\n *   ...process.env,\n *   ...Credentials,\n * });\n * ```\n */\nexport async function runInitScript(\n\tscriptPath: string,\n\tdatabaseUrl: string,\n\tenv?: Record<string, string>,\n): Promise<void> {\n\tconst content = readFileSync(scriptPath, 'utf-8');\n\tconst resolvedEnv = env ?? ({ ...process.env } as Record<string, string>);\n\tconst blocks = parseInitScript(content, resolvedEnv);\n\n\tif (blocks.length === 0) {\n\t\treturn;\n\t}\n\n\tconst url = new URL(databaseUrl);\n\tconst client = new Client({\n\t\tuser: url.username,\n\t\tpassword: decodeURIComponent(url.password),\n\t\thost: url.hostname,\n\t\tport: parseInt(url.port, 10),\n\t\tdatabase: url.pathname.slice(1),\n\t});\n\n\ttry {\n\t\tawait client.connect();\n\t\tfor (const sql of blocks) {\n\t\t\tawait client.query(sql);\n\t\t}\n\t} finally {\n\t\tawait client.end();\n\t}\n}\n"],"mappings":";;;;;AAGA,MAAM,EAAE,QAAQ,GAAG;;;;;;;;;;AAWnB,SAAgB,gBACfA,SACAC,KACW;CACX,MAAMC,SAAmB,CAAE;CAC3B,MAAM,QAAQ,QAAQ,MAAM,KAAK;CACjC,IAAI,YAAY;CAChB,IAAIC,eAAyB,CAAE;AAE/B,MAAK,MAAM,QAAQ,MAClB,KAAI,UAEH,KAAI,gBAAgB,KAAK,KAAK,EAAE;EAC/B,MAAM,MAAM,kBAAkB,aAAa,KAAK,KAAK,EAAE,IAAI;AAC3D,SAAO,KAAK,IAAI;AAChB,iBAAe,CAAE;AACjB,cAAY;CACZ,MACA,cAAa,KAAK,KAAK;UAGxB,KAAK,SAAS,WAAW,IACzB,KAAK,SAAS,WAAW,IACzB,KAAK,SAAS,UAAU,EACvB;AACD,cAAY;AACZ,iBAAe,CAAE;CACjB;AAGF,QAAO;AACP;;;;;AAMD,SAAS,kBAAkBC,KAAaH,KAAqC;CAE5E,IAAI,SAAS,IAAI,QAAQ,gBAAgB,CAAC,GAAG,SAAS,IAAI,SAAS,GAAG;AAEtE,UAAS,OAAO,QAAQ,YAAY,CAAC,GAAG,SAAS,IAAI,SAAS,GAAG;AAGjE,UAAS,OAAO,QAAQ,SAAS,IAAI;AACrC,QAAO;AACP;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+BD,eAAsB,cACrBI,YACAC,aACAC,KACgB;CAChB,MAAM,UAAU,0BAAa,YAAY,QAAQ;CACjD,MAAM,cAAc,OAAQ,EAAE,GAAG,QAAQ,IAAK;CAC9C,MAAM,SAAS,gBAAgB,SAAS,YAAY;AAEpD,KAAI,OAAO,WAAW,EACrB;CAGD,MAAM,MAAM,IAAI,IAAI;CACpB,MAAM,SAAS,IAAI,OAAO;EACzB,MAAM,IAAI;EACV,UAAU,mBAAmB,IAAI,SAAS;EAC1C,MAAM,IAAI;EACV,MAAM,SAAS,IAAI,MAAM,GAAG;EAC5B,UAAU,IAAI,SAAS,MAAM,EAAE;CAC/B;AAED,KAAI;AACH,QAAM,OAAO,SAAS;AACtB,OAAK,MAAM,OAAO,OACjB,OAAM,OAAO,MAAM,IAAI;CAExB,UAAS;AACT,QAAM,OAAO,KAAK;CAClB;AACD"}
+{"version":3,"file":"initScript.cjs","names":["readFileSync"],"sources":["../src/initScript.ts"],"sourcesContent":["import { readFileSync } from 'node:fs';\nimport pg from 'pg';\n\nconst { Client } = pg;\n\n/**\n * Parse a shell init script (like docker/postgres/init.sh) and extract\n * SQL blocks from heredoc sections (<<-EOSQL ... EOSQL).\n *\n * @param content - The shell script content\n * @param env - Environment variables to substitute ($VAR_NAME references)\n * @returns Array of SQL strings ready to execute\n * @internal Exported for testing\n */\nexport function parseInitScript(\n\tcontent: string,\n\tenv: Record<string, string>,\n): string[] {\n\tconst blocks: string[] = [];\n\tconst lines = content.split('\\n');\n\tlet inHeredoc = false;\n\tlet currentBlock: string[] = [];\n\n\tfor (const line of lines) {\n\t\tif (inHeredoc) {\n\t\t\t// Check for heredoc terminator (EOSQL at start of line, with optional leading whitespace)\n\t\t\tif (/^\\s*EOSQL\\s*$/.test(line)) {\n\t\t\t\tconst sql = substituteEnvVars(currentBlock.join('\\n'), env);\n\t\t\t\tblocks.push(sql);\n\t\t\t\tcurrentBlock = [];\n\t\t\t\tinHeredoc = false;\n\t\t\t} else {\n\t\t\t\tcurrentBlock.push(line);\n\t\t\t}\n\t\t} else if (\n\t\t\tline.includes('<<-EOSQL') ||\n\t\t\tline.includes('<< EOSQL') ||\n\t\t\tline.includes('<<EOSQL')\n\t\t) {\n\t\t\tinHeredoc = true;\n\t\t\tcurrentBlock = [];\n\t\t}\n\t}\n\n\treturn blocks;\n}\n\n/**\n * Replace shell variable references ($VAR_NAME and ${VAR_NAME})\n * with values from the provided env object.\n */\nfunction substituteEnvVars(sql: string, env: Record<string, string>): string {\n\t// Replace ${VAR_NAME} syntax\n\tlet result = sql.replace(/\\$\\{(\\w+)\\}/g, (_, name) => env[name] ?? '');\n\t// Replace $VAR_NAME syntax (word boundary after)\n\tresult = result.replace(/\\$(\\w+)/g, (_, name) => env[name] ?? '');\n\t// Unescape bash-escaped dollar signs (\\$ → $) AFTER variable substitution\n\t// This handles PL/pgSQL dollar-quoting like DO \\$\\$ ... END \\$\\$;\n\tresult = result.replace(/\\\\\\$/g, '$');\n\treturn result;\n}\n\n/**\n * Read a postgres init script, parse out the SQL blocks,\n * substitute environment variables, and execute against a database.\n *\n * This is intended to run `docker/postgres/init.sh` against a test database\n * so that per-app users and schemas are created (matching what Docker does\n * on first volume initialization).\n *\n * Uses `CREATE ... IF NOT EXISTS` and `DO $$ ... END $$` wrappers where\n * needed so the script is idempotent.\n *\n * @param scriptPath - Path to the init.sh file\n * @param databaseUrl - PostgreSQL connection URL (should point to the test database)\n *\n * @example\n * ```typescript\n * // In your globalSetup.ts\n * import { runInitScript } from '@geekmidas/testkit/postgres';\n * import { Credentials } from '@geekmidas/envkit/credentials';\n *\n * const cleanup = await migrator.start();\n *\n * // Create per-app users in the test database\n * await runInitScript('docker/postgres/init.sh', Credentials.DATABASE_URL, {\n *   ...process.env,\n *   ...Credentials,\n * });\n * ```\n */\nexport async function runInitScript(\n\tscriptPath: string,\n\tdatabaseUrl: string,\n\tenv?: Record<string, string>,\n): Promise<void> {\n\tconst content = readFileSync(scriptPath, 'utf-8');\n\tconst resolvedEnv = env ?? ({ ...process.env } as Record<string, string>);\n\tconst blocks = parseInitScript(content, resolvedEnv);\n\n\tif (blocks.length === 0) {\n\t\treturn;\n\t}\n\n\tconst url = new URL(databaseUrl);\n\tconst client = new Client({\n\t\tuser: url.username,\n\t\tpassword: decodeURIComponent(url.password),\n\t\thost: url.hostname,\n\t\tport: parseInt(url.port, 10),\n\t\tdatabase: url.pathname.slice(1),\n\t});\n\n\ttry {\n\t\tawait client.connect();\n\t\tfor (const sql of blocks) {\n\t\t\tawait client.query(sql);\n\t\t}\n\t} finally {\n\t\tawait client.end();\n\t}\n}\n"],"mappings":";;;;;;AAGA,MAAM,EAAE,WAAW,GAAA;;;;;;;;;;AAWnB,SAAgB,gBACf,SACA,KACW;CACX,MAAM,SAAmB,CAAC;CAC1B,MAAM,QAAQ,QAAQ,MAAM,IAAI;CAChC,IAAI,YAAY;CAChB,IAAI,eAAyB,CAAC;CAE9B,KAAK,MAAM,QAAQ,OAClB,IAAI,WAAW;EAEd,IAAI,gBAAgB,KAAK,IAAI,GAAG;GAC/B,MAAM,MAAM,kBAAkB,aAAa,KAAK,IAAI,GAAG,GAAG;GAC1D,OAAO,KAAK,GAAG;GACf,eAAe,CAAC;GAChB,YAAY;EACb,OACC,aAAa,KAAK,IAAI;CAExB,OAAO,IACN,KAAK,SAAS,UAAU,KACxB,KAAK,SAAS,UAAU,KACxB,KAAK,SAAS,SAAS,GACtB;EACD,YAAY;EACZ,eAAe,CAAC;CACjB;CAGD,OAAO;AACR;;;;;AAMA,SAAS,kBAAkB,KAAa,KAAqC;CAE5E,IAAI,SAAS,IAAI,QAAQ,iBAAiB,GAAG,SAAS,IAAI,SAAS,EAAE;CAErE,SAAS,OAAO,QAAQ,aAAa,GAAG,SAAS,IAAI,SAAS,EAAE;CAGhE,SAAS,OAAO,QAAQ,SAAS,GAAG;CACpC,OAAO;AACR;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+BA,eAAsB,cACrB,YACA,aACA,KACgB;CAGhB,MAAM,SAAS,iBAAA,GAFCA,QAAAA,aAAAA,CAAa,YAAY,OAEJ,GADjB,OAAQ,EAAE,GAAG,QAAQ,IAAI,CACM;CAEnD,IAAI,OAAO,WAAW,GACrB;CAGD,MAAM,MAAM,IAAI,IAAI,WAAW;CAC/B,MAAM,SAAS,IAAI,OAAO;EACzB,MAAM,IAAI;EACV,UAAU,mBAAmB,IAAI,QAAQ;EACzC,MAAM,IAAI;EACV,MAAM,SAAS,IAAI,MAAM,EAAE;EAC3B,UAAU,IAAI,SAAS,MAAM,CAAC;CAC/B,CAAC;CAED,IAAI;EACH,MAAM,OAAO,QAAQ;EACrB,KAAK,MAAM,OAAO,QACjB,MAAM,OAAO,MAAM,GAAG;CAExB,UAAU;EACT,MAAM,OAAO,IAAI;CAClB;AACD"}

package/dist/initScript.d.cts

@@ -8,7 +8,7 @@
  * @returns Array of SQL strings ready to execute
  * @internal Exported for testing
  */
-declare function parseInitScript(content: string, env: Record<string, string>): string[];
+export declare function parseInitScript(content: string, env: Record<string, string>): string[];
 /**
  * Read a postgres init script, parse out the SQL blocks,
  * substitute environment variables, and execute against a database.
@@ -38,8 +38,6 @@ declare function parseInitScript(content: string, env: Record<string, string>):
  * });
  * ```
  */
-declare function runInitScript(scriptPath: string, databaseUrl: string, env?: Record<string, string>): Promise<void>;
-//# sourceMappingURL=initScript.d.ts.map
+export declare function runInitScript(scriptPath: string, databaseUrl: string, env?: Record<string, string>): Promise<void>;
 //#endregion
-export { parseInitScript, runInitScript };
 //# sourceMappingURL=initScript.d.cts.map

package/dist/initScript.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"initScript.d.cts","names":[],"sources":["../src/initScript.ts"],"sourcesContent":[],"mappings":";;AAcA;AA6EA;;;;AAIU;;;iBAjFM,eAAA,uBAEV;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA2EgB,aAAA,gDAGf,yBACJ"}
+{"version":3,"file":"initScript.d.cts","names":[],"sources":["../src/initScript.ts"],"mappings":";;;;;;;;;;wBAcgB,gBACf,iBACA,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBA2EgB,cACrB,oBACA,qBACA,MAAM,yBACJ"}

package/dist/initScript.d.mts

@@ -8,7 +8,7 @@
  * @returns Array of SQL strings ready to execute
  * @internal Exported for testing
  */
-declare function parseInitScript(content: string, env: Record<string, string>): string[];
+export declare function parseInitScript(content: string, env: Record<string, string>): string[];
 /**
  * Read a postgres init script, parse out the SQL blocks,
  * substitute environment variables, and execute against a database.
@@ -38,8 +38,6 @@ declare function parseInitScript(content: string, env: Record<string, string>):
  * });
  * ```
  */
-declare function runInitScript(scriptPath: string, databaseUrl: string, env?: Record<string, string>): Promise<void>;
-//# sourceMappingURL=initScript.d.ts.map
+export declare function runInitScript(scriptPath: string, databaseUrl: string, env?: Record<string, string>): Promise<void>;
 //#endregion
-export { parseInitScript, runInitScript };
 //# sourceMappingURL=initScript.d.mts.map

package/dist/initScript.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"initScript.d.mts","names":[],"sources":["../src/initScript.ts"],"sourcesContent":[],"mappings":";;AAcA;AA6EA;;;;AAIU;;;iBAjFM,eAAA,uBAEV;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA2EgB,aAAA,gDAGf,yBACJ"}
+{"version":3,"file":"initScript.d.mts","names":[],"sources":["../src/initScript.ts"],"mappings":";;;;;;;;;;wBAcgB,gBACf,iBACA,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBA2EgB,cACrB,oBACA,qBACA,MAAM,yBACJ"}

package/dist/initScript.mjs

@@ -1,6 +1,5 @@
 import pg from "pg";
 import { readFileSync } from "node:fs";
-
 //#region src/initScript.ts
 const { Client } = pg;
 /**
@@ -17,13 +16,14 @@ function parseInitScript(content, env) {
 	const lines = content.split("\n");
 	let inHeredoc = false;
 	let currentBlock = [];
-	for (const line of lines) if (inHeredoc) if (/^\s*EOSQL\s*$/.test(line)) {
-		const sql = substituteEnvVars(currentBlock.join("\n"), env);
-		blocks.push(sql);
-		currentBlock = [];
-		inHeredoc = false;
-	} else currentBlock.push(line);
-	else if (line.includes("<<-EOSQL") || line.includes("<< EOSQL") || line.includes("<<EOSQL")) {
+	for (const line of lines) if (inHeredoc) {
+		if (/^\s*EOSQL\s*$/.test(line)) {
+			const sql = substituteEnvVars(currentBlock.join("\n"), env);
+			blocks.push(sql);
+			currentBlock = [];
+			inHeredoc = false;
+		} else currentBlock.push(line);
+	} else if (line.includes("<<-EOSQL") || line.includes("<< EOSQL") || line.includes("<<EOSQL")) {
 		inHeredoc = true;
 		currentBlock = [];
 	}
@@ -69,9 +69,7 @@ function substituteEnvVars(sql, env) {
 * ```
 */
 async function runInitScript(scriptPath, databaseUrl, env) {
-	const content = readFileSync(scriptPath, "utf-8");
-	const resolvedEnv = env ?? { ...process.env };
-	const blocks = parseInitScript(content, resolvedEnv);
+	const blocks = parseInitScript(readFileSync(scriptPath, "utf-8"), env ?? { ...process.env });
 	if (blocks.length === 0) return;
 	const url = new URL(databaseUrl);
 	const client = new Client({
@@ -88,7 +86,7 @@ async function runInitScript(scriptPath, databaseUrl, env) {
 		await client.end();
 	}
 }
-
 //#endregion
 export { parseInitScript, runInitScript };
+
 //# sourceMappingURL=initScript.mjs.map

package/dist/initScript.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"initScript.mjs","names":["content: string","env: Record<string, string>","blocks: string[]","currentBlock: string[]","sql: string","scriptPath: string","databaseUrl: string","env?: Record<string, string>"],"sources":["../src/initScript.ts"],"sourcesContent":["import { readFileSync } from 'node:fs';\nimport pg from 'pg';\n\nconst { Client } = pg;\n\n/**\n * Parse a shell init script (like docker/postgres/init.sh) and extract\n * SQL blocks from heredoc sections (<<-EOSQL ... EOSQL).\n *\n * @param content - The shell script content\n * @param env - Environment variables to substitute ($VAR_NAME references)\n * @returns Array of SQL strings ready to execute\n * @internal Exported for testing\n */\nexport function parseInitScript(\n\tcontent: string,\n\tenv: Record<string, string>,\n): string[] {\n\tconst blocks: string[] = [];\n\tconst lines = content.split('\\n');\n\tlet inHeredoc = false;\n\tlet currentBlock: string[] = [];\n\n\tfor (const line of lines) {\n\t\tif (inHeredoc) {\n\t\t\t// Check for heredoc terminator (EOSQL at start of line, with optional leading whitespace)\n\t\t\tif (/^\\s*EOSQL\\s*$/.test(line)) {\n\t\t\t\tconst sql = substituteEnvVars(currentBlock.join('\\n'), env);\n\t\t\t\tblocks.push(sql);\n\t\t\t\tcurrentBlock = [];\n\t\t\t\tinHeredoc = false;\n\t\t\t} else {\n\t\t\t\tcurrentBlock.push(line);\n\t\t\t}\n\t\t} else if (\n\t\t\tline.includes('<<-EOSQL') ||\n\t\t\tline.includes('<< EOSQL') ||\n\t\t\tline.includes('<<EOSQL')\n\t\t) {\n\t\t\tinHeredoc = true;\n\t\t\tcurrentBlock = [];\n\t\t}\n\t}\n\n\treturn blocks;\n}\n\n/**\n * Replace shell variable references ($VAR_NAME and ${VAR_NAME})\n * with values from the provided env object.\n */\nfunction substituteEnvVars(sql: string, env: Record<string, string>): string {\n\t// Replace ${VAR_NAME} syntax\n\tlet result = sql.replace(/\\$\\{(\\w+)\\}/g, (_, name) => env[name] ?? '');\n\t// Replace $VAR_NAME syntax (word boundary after)\n\tresult = result.replace(/\\$(\\w+)/g, (_, name) => env[name] ?? '');\n\t// Unescape bash-escaped dollar signs (\\$ → $) AFTER variable substitution\n\t// This handles PL/pgSQL dollar-quoting like DO \\$\\$ ... END \\$\\$;\n\tresult = result.replace(/\\\\\\$/g, '$');\n\treturn result;\n}\n\n/**\n * Read a postgres init script, parse out the SQL blocks,\n * substitute environment variables, and execute against a database.\n *\n * This is intended to run `docker/postgres/init.sh` against a test database\n * so that per-app users and schemas are created (matching what Docker does\n * on first volume initialization).\n *\n * Uses `CREATE ... IF NOT EXISTS` and `DO $$ ... END $$` wrappers where\n * needed so the script is idempotent.\n *\n * @param scriptPath - Path to the init.sh file\n * @param databaseUrl - PostgreSQL connection URL (should point to the test database)\n *\n * @example\n * ```typescript\n * // In your globalSetup.ts\n * import { runInitScript } from '@geekmidas/testkit/postgres';\n * import { Credentials } from '@geekmidas/envkit/credentials';\n *\n * const cleanup = await migrator.start();\n *\n * // Create per-app users in the test database\n * await runInitScript('docker/postgres/init.sh', Credentials.DATABASE_URL, {\n *   ...process.env,\n *   ...Credentials,\n * });\n * ```\n */\nexport async function runInitScript(\n\tscriptPath: string,\n\tdatabaseUrl: string,\n\tenv?: Record<string, string>,\n): Promise<void> {\n\tconst content = readFileSync(scriptPath, 'utf-8');\n\tconst resolvedEnv = env ?? ({ ...process.env } as Record<string, string>);\n\tconst blocks = parseInitScript(content, resolvedEnv);\n\n\tif (blocks.length === 0) {\n\t\treturn;\n\t}\n\n\tconst url = new URL(databaseUrl);\n\tconst client = new Client({\n\t\tuser: url.username,\n\t\tpassword: decodeURIComponent(url.password),\n\t\thost: url.hostname,\n\t\tport: parseInt(url.port, 10),\n\t\tdatabase: url.pathname.slice(1),\n\t});\n\n\ttry {\n\t\tawait client.connect();\n\t\tfor (const sql of blocks) {\n\t\t\tawait client.query(sql);\n\t\t}\n\t} finally {\n\t\tawait client.end();\n\t}\n}\n"],"mappings":";;;;AAGA,MAAM,EAAE,QAAQ,GAAG;;;;;;;;;;AAWnB,SAAgB,gBACfA,SACAC,KACW;CACX,MAAMC,SAAmB,CAAE;CAC3B,MAAM,QAAQ,QAAQ,MAAM,KAAK;CACjC,IAAI,YAAY;CAChB,IAAIC,eAAyB,CAAE;AAE/B,MAAK,MAAM,QAAQ,MAClB,KAAI,UAEH,KAAI,gBAAgB,KAAK,KAAK,EAAE;EAC/B,MAAM,MAAM,kBAAkB,aAAa,KAAK,KAAK,EAAE,IAAI;AAC3D,SAAO,KAAK,IAAI;AAChB,iBAAe,CAAE;AACjB,cAAY;CACZ,MACA,cAAa,KAAK,KAAK;UAGxB,KAAK,SAAS,WAAW,IACzB,KAAK,SAAS,WAAW,IACzB,KAAK,SAAS,UAAU,EACvB;AACD,cAAY;AACZ,iBAAe,CAAE;CACjB;AAGF,QAAO;AACP;;;;;AAMD,SAAS,kBAAkBC,KAAaH,KAAqC;CAE5E,IAAI,SAAS,IAAI,QAAQ,gBAAgB,CAAC,GAAG,SAAS,IAAI,SAAS,GAAG;AAEtE,UAAS,OAAO,QAAQ,YAAY,CAAC,GAAG,SAAS,IAAI,SAAS,GAAG;AAGjE,UAAS,OAAO,QAAQ,SAAS,IAAI;AACrC,QAAO;AACP;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+BD,eAAsB,cACrBI,YACAC,aACAC,KACgB;CAChB,MAAM,UAAU,aAAa,YAAY,QAAQ;CACjD,MAAM,cAAc,OAAQ,EAAE,GAAG,QAAQ,IAAK;CAC9C,MAAM,SAAS,gBAAgB,SAAS,YAAY;AAEpD,KAAI,OAAO,WAAW,EACrB;CAGD,MAAM,MAAM,IAAI,IAAI;CACpB,MAAM,SAAS,IAAI,OAAO;EACzB,MAAM,IAAI;EACV,UAAU,mBAAmB,IAAI,SAAS;EAC1C,MAAM,IAAI;EACV,MAAM,SAAS,IAAI,MAAM,GAAG;EAC5B,UAAU,IAAI,SAAS,MAAM,EAAE;CAC/B;AAED,KAAI;AACH,QAAM,OAAO,SAAS;AACtB,OAAK,MAAM,OAAO,OACjB,OAAM,OAAO,MAAM,IAAI;CAExB,UAAS;AACT,QAAM,OAAO,KAAK;CAClB;AACD"}
+{"version":3,"file":"initScript.mjs","names":[],"sources":["../src/initScript.ts"],"sourcesContent":["import { readFileSync } from 'node:fs';\nimport pg from 'pg';\n\nconst { Client } = pg;\n\n/**\n * Parse a shell init script (like docker/postgres/init.sh) and extract\n * SQL blocks from heredoc sections (<<-EOSQL ... EOSQL).\n *\n * @param content - The shell script content\n * @param env - Environment variables to substitute ($VAR_NAME references)\n * @returns Array of SQL strings ready to execute\n * @internal Exported for testing\n */\nexport function parseInitScript(\n\tcontent: string,\n\tenv: Record<string, string>,\n): string[] {\n\tconst blocks: string[] = [];\n\tconst lines = content.split('\\n');\n\tlet inHeredoc = false;\n\tlet currentBlock: string[] = [];\n\n\tfor (const line of lines) {\n\t\tif (inHeredoc) {\n\t\t\t// Check for heredoc terminator (EOSQL at start of line, with optional leading whitespace)\n\t\t\tif (/^\\s*EOSQL\\s*$/.test(line)) {\n\t\t\t\tconst sql = substituteEnvVars(currentBlock.join('\\n'), env);\n\t\t\t\tblocks.push(sql);\n\t\t\t\tcurrentBlock = [];\n\t\t\t\tinHeredoc = false;\n\t\t\t} else {\n\t\t\t\tcurrentBlock.push(line);\n\t\t\t}\n\t\t} else if (\n\t\t\tline.includes('<<-EOSQL') ||\n\t\t\tline.includes('<< EOSQL') ||\n\t\t\tline.includes('<<EOSQL')\n\t\t) {\n\t\t\tinHeredoc = true;\n\t\t\tcurrentBlock = [];\n\t\t}\n\t}\n\n\treturn blocks;\n}\n\n/**\n * Replace shell variable references ($VAR_NAME and ${VAR_NAME})\n * with values from the provided env object.\n */\nfunction substituteEnvVars(sql: string, env: Record<string, string>): string {\n\t// Replace ${VAR_NAME} syntax\n\tlet result = sql.replace(/\\$\\{(\\w+)\\}/g, (_, name) => env[name] ?? '');\n\t// Replace $VAR_NAME syntax (word boundary after)\n\tresult = result.replace(/\\$(\\w+)/g, (_, name) => env[name] ?? '');\n\t// Unescape bash-escaped dollar signs (\\$ → $) AFTER variable substitution\n\t// This handles PL/pgSQL dollar-quoting like DO \\$\\$ ... END \\$\\$;\n\tresult = result.replace(/\\\\\\$/g, '$');\n\treturn result;\n}\n\n/**\n * Read a postgres init script, parse out the SQL blocks,\n * substitute environment variables, and execute against a database.\n *\n * This is intended to run `docker/postgres/init.sh` against a test database\n * so that per-app users and schemas are created (matching what Docker does\n * on first volume initialization).\n *\n * Uses `CREATE ... IF NOT EXISTS` and `DO $$ ... END $$` wrappers where\n * needed so the script is idempotent.\n *\n * @param scriptPath - Path to the init.sh file\n * @param databaseUrl - PostgreSQL connection URL (should point to the test database)\n *\n * @example\n * ```typescript\n * // In your globalSetup.ts\n * import { runInitScript } from '@geekmidas/testkit/postgres';\n * import { Credentials } from '@geekmidas/envkit/credentials';\n *\n * const cleanup = await migrator.start();\n *\n * // Create per-app users in the test database\n * await runInitScript('docker/postgres/init.sh', Credentials.DATABASE_URL, {\n *   ...process.env,\n *   ...Credentials,\n * });\n * ```\n */\nexport async function runInitScript(\n\tscriptPath: string,\n\tdatabaseUrl: string,\n\tenv?: Record<string, string>,\n): Promise<void> {\n\tconst content = readFileSync(scriptPath, 'utf-8');\n\tconst resolvedEnv = env ?? ({ ...process.env } as Record<string, string>);\n\tconst blocks = parseInitScript(content, resolvedEnv);\n\n\tif (blocks.length === 0) {\n\t\treturn;\n\t}\n\n\tconst url = new URL(databaseUrl);\n\tconst client = new Client({\n\t\tuser: url.username,\n\t\tpassword: decodeURIComponent(url.password),\n\t\thost: url.hostname,\n\t\tport: parseInt(url.port, 10),\n\t\tdatabase: url.pathname.slice(1),\n\t});\n\n\ttry {\n\t\tawait client.connect();\n\t\tfor (const sql of blocks) {\n\t\t\tawait client.query(sql);\n\t\t}\n\t} finally {\n\t\tawait client.end();\n\t}\n}\n"],"mappings":";;;AAGA,MAAM,EAAE,WAAW;;;;;;;;;;AAWnB,SAAgB,gBACf,SACA,KACW;CACX,MAAM,SAAmB,CAAC;CAC1B,MAAM,QAAQ,QAAQ,MAAM,IAAI;CAChC,IAAI,YAAY;CAChB,IAAI,eAAyB,CAAC;CAE9B,KAAK,MAAM,QAAQ,OAClB,IAAI,WAAW;EAEd,IAAI,gBAAgB,KAAK,IAAI,GAAG;GAC/B,MAAM,MAAM,kBAAkB,aAAa,KAAK,IAAI,GAAG,GAAG;GAC1D,OAAO,KAAK,GAAG;GACf,eAAe,CAAC;GAChB,YAAY;EACb,OACC,aAAa,KAAK,IAAI;CAExB,OAAO,IACN,KAAK,SAAS,UAAU,KACxB,KAAK,SAAS,UAAU,KACxB,KAAK,SAAS,SAAS,GACtB;EACD,YAAY;EACZ,eAAe,CAAC;CACjB;CAGD,OAAO;AACR;;;;;AAMA,SAAS,kBAAkB,KAAa,KAAqC;CAE5E,IAAI,SAAS,IAAI,QAAQ,iBAAiB,GAAG,SAAS,IAAI,SAAS,EAAE;CAErE,SAAS,OAAO,QAAQ,aAAa,GAAG,SAAS,IAAI,SAAS,EAAE;CAGhE,SAAS,OAAO,QAAQ,SAAS,GAAG;CACpC,OAAO;AACR;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+BA,eAAsB,cACrB,YACA,aACA,KACgB;CAGhB,MAAM,SAAS,gBAFC,aAAa,YAAY,OAEJ,GADjB,OAAQ,EAAE,GAAG,QAAQ,IAAI,CACM;CAEnD,IAAI,OAAO,WAAW,GACrB;CAGD,MAAM,MAAM,IAAI,IAAI,WAAW;CAC/B,MAAM,SAAS,IAAI,OAAO;EACzB,MAAM,IAAI;EACV,UAAU,mBAAmB,IAAI,QAAQ;EACzC,MAAM,IAAI;EACV,MAAM,SAAS,IAAI,MAAM,EAAE;EAC3B,UAAU,IAAI,SAAS,MAAM,CAAC;CAC/B,CAAC;CAED,IAAI;EACH,MAAM,OAAO,QAAQ;EACrB,KAAK,MAAM,OAAO,QACjB,MAAM,OAAO,MAAM,GAAG;CAExB,UAAU;EACT,MAAM,OAAO,IAAI;CAClB;AACD"}

package/dist/kysely.cjs

@@ -1,11 +1,9 @@
-require('./Factory-BhjUOBWN.cjs');
-const require_faker = require('./faker-B14IEMIN.cjs');
-const require_KyselyFactory = require('./KyselyFactory-BFqVIn_0.cjs');
-require('./PostgresMigrator-M9jpzOvN.cjs');
-const require_PostgresKyselyMigrator = require('./PostgresKyselyMigrator-BGBxjnFv.cjs');
-const require_VitestTransactionIsolator = require('./VitestTransactionIsolator-DyiX-QtK.cjs');
-const require_VitestKyselyTransactionIsolator = require('./VitestKyselyTransactionIsolator-BjJSXryR.cjs');
-
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_faker = require("./faker.cjs");
+const require_KyselyFactory = require("./KyselyFactory.cjs");
+const require_PostgresKyselyMigrator = require("./PostgresKyselyMigrator.cjs");
+const require_VitestTransactionIsolator = require("./VitestTransactionIsolator.cjs");
+const require_VitestKyselyTransactionIsolator = require("./VitestKyselyTransactionIsolator.cjs");
 //#region src/kysely.ts
 /**
 * Creates a wrapped Vitest test API with automatic transaction rollback for Kysely.
@@ -55,8 +53,7 @@ const require_VitestKyselyTransactionIsolator = require('./VitestKyselyTransacti
 * ```
 */
 function wrapVitestKyselyTransaction(api, options) {
-	const wrapper = new require_VitestKyselyTransactionIsolator.VitestKyselyTransactionIsolator(api);
-	return wrapper.wrapVitestWithTransaction(options);
+	return new require_VitestKyselyTransactionIsolator.VitestKyselyTransactionIsolator(api).wrapVitestWithTransaction(options);
 }
 /**
 * Extends a Kysely transaction-wrapped test with additional fixtures.
@@ -110,16 +107,16 @@ function wrapVitestKyselyTransaction(api, options) {
 * });
 * ```
 */
-function extendWithFixtures$1(wrappedTest, fixtures) {
+function extendWithFixtures(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.extendWithFixtures = extendWithFixtures;
 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","options: KyselyTransactionOptions<Database, Extended>","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\textendWithFixtures as baseExtendWithFixtures,\n\ttype DatabaseConnection,\n\ttype FixtureCreators,\n\ttype 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 type { ExtractSeedAttrs, FactorySeed } from './Factory';\nexport { KyselyFactory } from './KyselyFactory';\nexport { PostgresKyselyMigrator } from './PostgresKyselyMigrator';\nexport { VitestKyselyTransactionIsolator } from './VitestKyselyTransactionIsolator';\nexport type {\n\tDatabaseFixtures,\n\tExtendedDatabaseFixtures,\n\tFixtureCreators,\n\tTestWithExtendedFixtures,\n\tTransactionWrapperOptions,\n} from './VitestTransactionIsolator';\nexport { IsolationLevel } from './VitestTransactionIsolator';\n\n/**\n * Kysely-specific options for transaction wrapping.\n */\nexport interface KyselyTransactionOptions<\n\tDatabase,\n\tExtended extends Record<string, unknown> = {},\n> {\n\t/** Function that creates or returns a Kysely database instance */\n\tconnection: DatabaseConnection<Kysely<Database>>;\n\t/** Optional setup function to run within the transaction before each test */\n\tsetup?: (trx: Transaction<Database>) => Promise<void>;\n\t/** Transaction isolation level (defaults to REPEATABLE_READ) */\n\tisolationLevel?: IsolationLevel;\n\t/** Additional fixtures that depend on the transaction */\n\tfixtures?: FixtureCreators<Transaction<Database>, Extended>;\n}\n\n// Re-export faker and FakerFactory for type portability in declaration files\nexport { type FakerFactory, faker } 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 * @template Extended - Additional fixtures to provide\n * @param api - The Vitest test API (usually `test` from vitest)\n * @param options - Configuration options for transaction wrapping\n * @returns A wrapped test API that provides transaction isolation\n *\n * @example\n * ```typescript\n * import { test } from 'vitest';\n * import { wrapVitestKyselyTransaction } from '@geekmidas/testkit/kysely';\n * import { db } from './database';\n *\n * // Create isolated test with automatic rollback\n * const isolatedTest = wrapVitestKyselyTransaction(test, {\n *   connection: db,\n * });\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 * });\n *\n * // With fixtures for factories\n * const it = wrapVitestKyselyTransaction<DB, { factory: Factory }>(test, {\n *   connection: db,\n *   fixtures: {\n *     factory: (trx) => new Factory(trx),\n *   },\n * });\n *\n * it('should create user with factory', async ({ trx, factory }) => {\n *   const user = await factory.insert('user', { name: 'Test' });\n *   expect(user.id).toBeDefined();\n * });\n * ```\n */\nexport function wrapVitestKyselyTransaction<\n\tDatabase,\n\tExtended extends Record<string, unknown> = {},\n>(api: TestAPI, options: KyselyTransactionOptions<Database, Extended>) {\n\tconst wrapper = new VitestKyselyTransactionIsolator<Database>(api);\n\n\treturn wrapper.wrapVitestWithTransaction(options);\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, {\n *   connection: db,\n *   setup: createTestTables,\n * });\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\tDatabase,\n\tExtended extends Record<string, unknown>,\n\tT extends ReturnType<TestAPI['extend']> = ReturnType<TestAPI['extend']>,\n>(wrappedTest: T, fixtures: FixtureCreators<Transaction<Database>, Extended>) {\n\treturn baseExtendWithFixtures<Transaction<Database>, Extended, T>(\n\t\twrappedTest,\n\t\tfixtures,\n\t);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+FA,SAAgB,4BAGdA,KAAcC,SAAuD;CACtE,MAAM,UAAU,IAAIC,wEAA0C;AAE9D,QAAO,QAAQ,0BAA0B,QAAQ;AACjD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAsDD,SAAgBC,qBAIdC,aAAgBC,UAA4D;AAC7E,QAAO,qDACN,aACA,SACA;AACD"}
+{"version":3,"file":"kysely.cjs","names":["VitestKyselyTransactionIsolator","baseExtendWithFixtures"],"sources":["../src/kysely.ts"],"sourcesContent":["import type { Kysely, Transaction } from 'kysely';\nimport type { TestAPI } from 'vitest';\nimport { VitestKyselyTransactionIsolator } from './VitestKyselyTransactionIsolator';\nimport {\n\textendWithFixtures as baseExtendWithFixtures,\n\ttype DatabaseConnection,\n\ttype FixtureCreators,\n\ttype 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 type { ExtractSeedAttrs, FactorySeed } from './Factory';\nexport { KyselyFactory } from './KyselyFactory';\nexport { PostgresKyselyMigrator } from './PostgresKyselyMigrator';\nexport { VitestKyselyTransactionIsolator } from './VitestKyselyTransactionIsolator';\nexport type {\n\tDatabaseFixtures,\n\tExtendedDatabaseFixtures,\n\tFixtureCreators,\n\tTestWithExtendedFixtures,\n\tTransactionWrapperOptions,\n} from './VitestTransactionIsolator';\nexport { IsolationLevel } from './VitestTransactionIsolator';\n\n/**\n * Kysely-specific options for transaction wrapping.\n */\nexport interface KyselyTransactionOptions<\n\tDatabase,\n\tExtended extends Record<string, unknown> = {},\n> {\n\t/** Function that creates or returns a Kysely database instance */\n\tconnection: DatabaseConnection<Kysely<Database>>;\n\t/** Optional setup function to run within the transaction before each test */\n\tsetup?: (trx: Transaction<Database>) => Promise<void>;\n\t/** Transaction isolation level (defaults to REPEATABLE_READ) */\n\tisolationLevel?: IsolationLevel;\n\t/** Additional fixtures that depend on the transaction */\n\tfixtures?: FixtureCreators<Transaction<Database>, Extended>;\n}\n\n// Re-export faker and FakerFactory for type portability in declaration files\nexport { type FakerFactory, faker } 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 * @template Extended - Additional fixtures to provide\n * @param api - The Vitest test API (usually `test` from vitest)\n * @param options - Configuration options for transaction wrapping\n * @returns A wrapped test API that provides transaction isolation\n *\n * @example\n * ```typescript\n * import { test } from 'vitest';\n * import { wrapVitestKyselyTransaction } from '@geekmidas/testkit/kysely';\n * import { db } from './database';\n *\n * // Create isolated test with automatic rollback\n * const isolatedTest = wrapVitestKyselyTransaction(test, {\n *   connection: db,\n * });\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 * });\n *\n * // With fixtures for factories\n * const it = wrapVitestKyselyTransaction<DB, { factory: Factory }>(test, {\n *   connection: db,\n *   fixtures: {\n *     factory: (trx) => new Factory(trx),\n *   },\n * });\n *\n * it('should create user with factory', async ({ trx, factory }) => {\n *   const user = await factory.insert('user', { name: 'Test' });\n *   expect(user.id).toBeDefined();\n * });\n * ```\n */\nexport function wrapVitestKyselyTransaction<\n\tDatabase,\n\tExtended extends Record<string, unknown> = {},\n>(api: TestAPI, options: KyselyTransactionOptions<Database, Extended>) {\n\tconst wrapper = new VitestKyselyTransactionIsolator<Database>(api);\n\n\treturn wrapper.wrapVitestWithTransaction(options);\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, {\n *   connection: db,\n *   setup: createTestTables,\n * });\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\tDatabase,\n\tExtended extends Record<string, unknown>,\n\tT extends ReturnType<TestAPI['extend']> = ReturnType<TestAPI['extend']>,\n>(wrappedTest: T, fixtures: FixtureCreators<Transaction<Database>, Extended>) {\n\treturn baseExtendWithFixtures<Transaction<Database>, Extended, T>(\n\t\twrappedTest,\n\t\tfixtures,\n\t);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+FA,SAAgB,4BAGd,KAAc,SAAuD;CAGtE,OAAO,IAFaA,wCAAAA,gCAA0C,GAEjD,CAAC,CAAC,0BAA0B,OAAO;AACjD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAsDA,SAAgB,mBAId,aAAgB,UAA4D;CAC7E,OAAOC,kCAAAA,mBACN,aACA,QACD;AACD"}

package/dist/kysely.d.cts

@@ -1,19 +1,16 @@
-import { FakerFactory, faker } from "./faker-DvxiCtxc.cjs";
-import { ExtractSeedAttrs, FactorySeed } from "./Factory-AWn1IulI.cjs";
-import { KyselyFactory } from "./KyselyFactory-CxUJCi--.cjs";
-import "./PostgresMigrator-CeYy-eHF.cjs";
-import { PostgresKyselyMigrator } from "./PostgresKyselyMigrator-B2M6Gjvv.cjs";
-import { DatabaseConnection, DatabaseFixtures, ExtendedDatabaseFixtures, FixtureCreators, IsolationLevel, TestWithExtendedFixtures, TransactionWrapperOptions } from "./VitestTransactionIsolator-glcxyS_R.cjs";
-import { VitestKyselyTransactionIsolator } from "./VitestKyselyTransactionIsolator-DJasVuIZ.cjs";
+import { FakerFactory, faker } from "./faker.cjs";
+import { ExtractSeedAttrs, FactorySeed } from "./Factory.cjs";
+import { KyselyFactory } from "./KyselyFactory.cjs";
+import { PostgresKyselyMigrator } from "./PostgresKyselyMigrator.cjs";
+import { DatabaseConnection, DatabaseFixtures, ExtendedDatabaseFixtures, FixtureCreators, IsolationLevel, TestWithExtendedFixtures, TransactionWrapperOptions } from "./VitestTransactionIsolator.cjs";
+import { VitestKyselyTransactionIsolator } from "./VitestKyselyTransactionIsolator.cjs";
 import { Kysely, Transaction } from "kysely";
 import { TestAPI } from "vitest";
-
 //#region src/kysely.d.ts
-
 /**
  * Kysely-specific options for transaction wrapping.
  */
-interface KyselyTransactionOptions<Database, Extended extends Record<string, unknown> = {}> {
+export interface KyselyTransactionOptions<Database, Extended extends Record<string, unknown> = {}> {
   /** Function that creates or returns a Kysely database instance */
   connection: DatabaseConnection<Kysely<Database>>;
   /** Optional setup function to run within the transaction before each test */
@@ -70,7 +67,7 @@ interface KyselyTransactionOptions<Database, Extended extends Record<string, unk
  * });
  * ```
  */
-declare function wrapVitestKyselyTransaction<Database, Extended extends Record<string, unknown> = {}>(api: TestAPI, options: KyselyTransactionOptions<Database, Extended>): TestAPI<DatabaseFixtures<Transaction<Database>, object> & Extended>;
+export declare function wrapVitestKyselyTransaction<Database, Extended extends Record<string, unknown> = {}>(api: TestAPI, options: KyselyTransactionOptions<Database, Extended>): TestAPI<DatabaseFixtures<Transaction<Database>, object> & Extended>;
 /**
  * Extends a Kysely transaction-wrapped test with additional fixtures.
  * Each fixture receives the transaction and can create dependencies like factories or repositories.
@@ -123,8 +120,7 @@ declare function wrapVitestKyselyTransaction<Database, Extended extends Record<s
  * });
  * ```
  */
-declare function extendWithFixtures<Database, Extended extends Record<string, unknown>, T extends ReturnType<TestAPI['extend']> = ReturnType<TestAPI['extend']>>(wrappedTest: T, fixtures: FixtureCreators<Transaction<Database>, Extended>): TestWithExtendedFixtures<Transaction<Database>, Extended, T>;
-//# sourceMappingURL=kysely.d.ts.map
+export declare function extendWithFixtures<Database, Extended extends Record<string, unknown>, T extends ReturnType<TestAPI['extend']> = ReturnType<TestAPI['extend']>>(wrappedTest: T, fixtures: FixtureCreators<Transaction<Database>, Extended>): TestWithExtendedFixtures<Transaction<Database>, Extended, T>;
 //#endregion
-export { DatabaseFixtures, ExtendedDatabaseFixtures, ExtractSeedAttrs, FactorySeed, FakerFactory, FixtureCreators, IsolationLevel, KyselyFactory, KyselyTransactionOptions, PostgresKyselyMigrator, TestWithExtendedFixtures, TransactionWrapperOptions, VitestKyselyTransactionIsolator, extendWithFixtures, faker, wrapVitestKyselyTransaction };
+export { type DatabaseFixtures, type ExtendedDatabaseFixtures, type ExtractSeedAttrs, type FactorySeed, type FakerFactory, type FixtureCreators, IsolationLevel, KyselyFactory, PostgresKyselyMigrator, type TestWithExtendedFixtures, type TransactionWrapperOptions, VitestKyselyTransactionIsolator, faker };
 //# sourceMappingURL=kysely.d.cts.map

package/dist/kysely.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"kysely.d.cts","names":[],"sources":["../src/kysely.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;;;;;;AAoCa,UALI,wBAKJ,CAAA,QAAA,EAAA,iBAHK,MAGL,CAAA,MAAA,EAAA,OAAA,CAAA,GAAA,CAAA,CAAA,CAAA,CAAA;EAAkB;EAEI,UAApB,EAFF,kBAEE,CAFiB,MAEjB,CAFwB,QAExB,CAAA,CAAA;EAAW;EAAsB,KAE9B,CAAA,EAAA,CAAA,GAAA,EAFH,WAEG,CAFS,QAET,CAAA,EAAA,GAFuB,OAEvB,CAAA,IAAA,CAAA;EAAc;EAEgB,cAApB,CAAA,EAFV,cAEU;EAAW;EAAoB,QAA/C,CAAA,EAAA,eAAA,CAAgB,WAAhB,CAA4B,QAA5B,CAAA,EAAuC,QAAvC,CAAA;AAAe;;;;;;;;;;;;AAwD0C;AA0DrE;;;;;;;;;;;;;;;;;AAI4E;;;;;;;;;;;;;;;;;;iBAjE5D,uDAEE,mCACX,kBAAkB,yBAAyB,UAAU,YAAS,QAAA,iBAAA,YAAA,qBAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA0DrD,8CAEE,mCACP,WAAW,qBAAqB,WAAW,iCACvC,aAAa,gBAAgB,YAAY,WAAW,YAAS,yBAAA,YAAA,WAAA,UAAA"}
+{"version":3,"file":"kysely.d.cts","names":["_$__VitestTransactionIsolator0.DatabaseFixtures","_$__VitestTransactionIsolator0.TestWithExtendedFixtures"],"sources":["../src/kysely.ts"],"mappings":";;;;;;;;;;;;iBA+BiB,yBAChB,UACA,iBAAiB;;EAGjB,YAAY,mBAAmB,OAAO;;EAEtC,SAAS,KAAK,YAAY,cAAc;;EAExC,iBAAiB;;EAEjB,WAAW,gBAAgB,YAAY,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBAqDnC,4BACf,UACA,iBAAiB,8BAChB,KAAK,SAAS,SAAS,yBAAyB,UAAU,YAAS,QAAAA,iBAAA,YAAA,qBAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBA0DrD,mBACf,UACA,iBAAiB,yBACjB,UAAU,WAAW,qBAAqB,WAAW,oBACpD,aAAa,GAAG,UAAU,gBAAgB,YAAY,WAAW,YAASC,yBAAA,YAAA,WAAA,UAAA"}

package/dist/kysely.d.mts

@@ -1,19 +1,16 @@
-import { FakerFactory, faker } from "./faker-B6bmbGCM.mjs";
-import { ExtractSeedAttrs, FactorySeed } from "./Factory-C15SSK8_.mjs";
-import { KyselyFactory } from "./KyselyFactory-C9Snz24z.mjs";
-import "./PostgresMigrator-C_QQ6q35.mjs";
-import { PostgresKyselyMigrator } from "./PostgresKyselyMigrator-CvwXycJE.mjs";
-import { DatabaseConnection, DatabaseFixtures, ExtendedDatabaseFixtures, FixtureCreators, IsolationLevel, TestWithExtendedFixtures, TransactionWrapperOptions } from "./VitestTransactionIsolator-BLaw80cx.mjs";
-import { VitestKyselyTransactionIsolator } from "./VitestKyselyTransactionIsolator-CwlTo6yf.mjs";
+import { FakerFactory, faker } from "./faker.mjs";
+import { ExtractSeedAttrs, FactorySeed } from "./Factory.mjs";
+import { KyselyFactory } from "./KyselyFactory.mjs";
+import { PostgresKyselyMigrator } from "./PostgresKyselyMigrator.mjs";
+import { DatabaseConnection, DatabaseFixtures, ExtendedDatabaseFixtures, FixtureCreators, IsolationLevel, TestWithExtendedFixtures, TransactionWrapperOptions } from "./VitestTransactionIsolator.mjs";
+import { VitestKyselyTransactionIsolator } from "./VitestKyselyTransactionIsolator.mjs";
 import { TestAPI } from "vitest";
 import { Kysely, Transaction } from "kysely";
-
 //#region src/kysely.d.ts
-
 /**
  * Kysely-specific options for transaction wrapping.
  */
-interface KyselyTransactionOptions<Database, Extended extends Record<string, unknown> = {}> {
+export interface KyselyTransactionOptions<Database, Extended extends Record<string, unknown> = {}> {
   /** Function that creates or returns a Kysely database instance */
   connection: DatabaseConnection<Kysely<Database>>;
   /** Optional setup function to run within the transaction before each test */
@@ -70,7 +67,7 @@ interface KyselyTransactionOptions<Database, Extended extends Record<string, unk
  * });
  * ```
  */
-declare function wrapVitestKyselyTransaction<Database, Extended extends Record<string, unknown> = {}>(api: TestAPI, options: KyselyTransactionOptions<Database, Extended>): TestAPI<DatabaseFixtures<Transaction<Database>, object> & Extended>;
+export declare function wrapVitestKyselyTransaction<Database, Extended extends Record<string, unknown> = {}>(api: TestAPI, options: KyselyTransactionOptions<Database, Extended>): TestAPI<DatabaseFixtures<Transaction<Database>, object> & Extended>;
 /**
  * Extends a Kysely transaction-wrapped test with additional fixtures.
  * Each fixture receives the transaction and can create dependencies like factories or repositories.
@@ -123,8 +120,7 @@ declare function wrapVitestKyselyTransaction<Database, Extended extends Record<s
  * });
  * ```
  */
-declare function extendWithFixtures<Database, Extended extends Record<string, unknown>, T extends ReturnType<TestAPI['extend']> = ReturnType<TestAPI['extend']>>(wrappedTest: T, fixtures: FixtureCreators<Transaction<Database>, Extended>): TestWithExtendedFixtures<Transaction<Database>, Extended, T>;
-//# sourceMappingURL=kysely.d.ts.map
+export declare function extendWithFixtures<Database, Extended extends Record<string, unknown>, T extends ReturnType<TestAPI['extend']> = ReturnType<TestAPI['extend']>>(wrappedTest: T, fixtures: FixtureCreators<Transaction<Database>, Extended>): TestWithExtendedFixtures<Transaction<Database>, Extended, T>;
 //#endregion
-export { DatabaseFixtures, ExtendedDatabaseFixtures, ExtractSeedAttrs, FactorySeed, FakerFactory, FixtureCreators, IsolationLevel, KyselyFactory, KyselyTransactionOptions, PostgresKyselyMigrator, TestWithExtendedFixtures, TransactionWrapperOptions, VitestKyselyTransactionIsolator, extendWithFixtures, faker, wrapVitestKyselyTransaction };
+export { type DatabaseFixtures, type ExtendedDatabaseFixtures, type ExtractSeedAttrs, type FactorySeed, type FakerFactory, type FixtureCreators, IsolationLevel, KyselyFactory, PostgresKyselyMigrator, type TestWithExtendedFixtures, type TransactionWrapperOptions, VitestKyselyTransactionIsolator, faker };
 //# sourceMappingURL=kysely.d.mts.map

package/dist/kysely.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"kysely.d.mts","names":[],"sources":["../src/kysely.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;;;;;;AAoCa,UALI,wBAKJ,CAAA,QAAA,EAAA,iBAHK,MAGL,CAAA,MAAA,EAAA,OAAA,CAAA,GAAA,CAAA,CAAA,CAAA,CAAA;EAAkB;EAEI,UAApB,EAFF,kBAEE,CAFiB,MAEjB,CAFwB,QAExB,CAAA,CAAA;EAAW;EAAsB,KAE9B,CAAA,EAAA,CAAA,GAAA,EAFH,WAEG,CAFS,QAET,CAAA,EAAA,GAFuB,OAEvB,CAAA,IAAA,CAAA;EAAc;EAEgB,cAApB,CAAA,EAFV,cAEU;EAAW;EAAoB,QAA/C,CAAA,EAAA,eAAA,CAAgB,WAAhB,CAA4B,QAA5B,CAAA,EAAuC,QAAvC,CAAA;AAAe;;;;;;;;;;;;AAwD0C;AA0DrE;;;;;;;;;;;;;;;;;AAI4E;;;;;;;;;;;;;;;;;;iBAjE5D,uDAEE,mCACX,kBAAkB,yBAAyB,UAAU,YAAS,QAAA,iBAAA,YAAA,qBAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA0DrD,8CAEE,mCACP,WAAW,qBAAqB,WAAW,iCACvC,aAAa,gBAAgB,YAAY,WAAW,YAAS,yBAAA,YAAA,WAAA,UAAA"}
+{"version":3,"file":"kysely.d.mts","names":["_$__VitestTransactionIsolator0.DatabaseFixtures","_$__VitestTransactionIsolator0.TestWithExtendedFixtures"],"sources":["../src/kysely.ts"],"mappings":";;;;;;;;;;;;iBA+BiB,yBAChB,UACA,iBAAiB;;EAGjB,YAAY,mBAAmB,OAAO;;EAEtC,SAAS,KAAK,YAAY,cAAc;;EAExC,iBAAiB;;EAEjB,WAAW,gBAAgB,YAAY,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBAqDnC,4BACf,UACA,iBAAiB,8BAChB,KAAK,SAAS,SAAS,yBAAyB,UAAU,YAAS,QAAAA,iBAAA,YAAA,qBAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBA0DrD,mBACf,UACA,iBAAiB,yBACjB,UAAU,WAAW,qBAAqB,WAAW,oBACpD,aAAa,GAAG,UAAU,gBAAgB,YAAY,WAAW,YAASC,yBAAA,YAAA,WAAA,UAAA"}

package/dist/kysely.mjs

@@ -1,11 +1,8 @@
-import "./Factory-BFVnMMCC.mjs";
-import { faker } from "./faker-BGKYFoCT.mjs";
-import { KyselyFactory } from "./KyselyFactory-DMswpwji.mjs";
-import "./PostgresMigrator-DVAY04qN.mjs";
-import { PostgresKyselyMigrator } from "./PostgresKyselyMigrator-PI0QhvB1.mjs";
-import { IsolationLevel, extendWithFixtures } from "./VitestTransactionIsolator-CvwPecpl.mjs";
-import { VitestKyselyTransactionIsolator } from "./VitestKyselyTransactionIsolator-1Saieke7.mjs";
-
+import { faker } from "./faker.mjs";
+import { KyselyFactory } from "./KyselyFactory.mjs";
+import { PostgresKyselyMigrator } from "./PostgresKyselyMigrator.mjs";
+import { IsolationLevel, extendWithFixtures as extendWithFixtures$1 } from "./VitestTransactionIsolator.mjs";
+import { VitestKyselyTransactionIsolator } from "./VitestKyselyTransactionIsolator.mjs";
 //#region src/kysely.ts
 /**
 * Creates a wrapped Vitest test API with automatic transaction rollback for Kysely.
@@ -55,8 +52,7 @@ import { VitestKyselyTransactionIsolator } from "./VitestKyselyTransactionIsolat
 * ```
 */
 function wrapVitestKyselyTransaction(api, options) {
-	const wrapper = new VitestKyselyTransactionIsolator(api);
-	return wrapper.wrapVitestWithTransaction(options);
+	return new VitestKyselyTransactionIsolator(api).wrapVitestWithTransaction(options);
 }
 /**
 * Extends a Kysely transaction-wrapped test with additional fixtures.
@@ -110,10 +106,10 @@ function wrapVitestKyselyTransaction(api, options) {
 * });
 * ```
 */
-function extendWithFixtures$1(wrappedTest, fixtures) {
-	return extendWithFixtures(wrappedTest, fixtures);
+function extendWithFixtures(wrappedTest, fixtures) {
+	return extendWithFixtures$1(wrappedTest, fixtures);
 }
-
 //#endregion
-export { IsolationLevel, KyselyFactory, PostgresKyselyMigrator, VitestKyselyTransactionIsolator, extendWithFixtures$1 as extendWithFixtures, faker, wrapVitestKyselyTransaction };
+export { IsolationLevel, KyselyFactory, PostgresKyselyMigrator, VitestKyselyTransactionIsolator, extendWithFixtures, faker, wrapVitestKyselyTransaction };
+
 //# sourceMappingURL=kysely.mjs.map

package/dist/kysely.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"kysely.mjs","names":["api: TestAPI","options: KyselyTransactionOptions<Database, Extended>","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\textendWithFixtures as baseExtendWithFixtures,\n\ttype DatabaseConnection,\n\ttype FixtureCreators,\n\ttype 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 type { ExtractSeedAttrs, FactorySeed } from './Factory';\nexport { KyselyFactory } from './KyselyFactory';\nexport { PostgresKyselyMigrator } from './PostgresKyselyMigrator';\nexport { VitestKyselyTransactionIsolator } from './VitestKyselyTransactionIsolator';\nexport type {\n\tDatabaseFixtures,\n\tExtendedDatabaseFixtures,\n\tFixtureCreators,\n\tTestWithExtendedFixtures,\n\tTransactionWrapperOptions,\n} from './VitestTransactionIsolator';\nexport { IsolationLevel } from './VitestTransactionIsolator';\n\n/**\n * Kysely-specific options for transaction wrapping.\n */\nexport interface KyselyTransactionOptions<\n\tDatabase,\n\tExtended extends Record<string, unknown> = {},\n> {\n\t/** Function that creates or returns a Kysely database instance */\n\tconnection: DatabaseConnection<Kysely<Database>>;\n\t/** Optional setup function to run within the transaction before each test */\n\tsetup?: (trx: Transaction<Database>) => Promise<void>;\n\t/** Transaction isolation level (defaults to REPEATABLE_READ) */\n\tisolationLevel?: IsolationLevel;\n\t/** Additional fixtures that depend on the transaction */\n\tfixtures?: FixtureCreators<Transaction<Database>, Extended>;\n}\n\n// Re-export faker and FakerFactory for type portability in declaration files\nexport { type FakerFactory, faker } 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 * @template Extended - Additional fixtures to provide\n * @param api - The Vitest test API (usually `test` from vitest)\n * @param options - Configuration options for transaction wrapping\n * @returns A wrapped test API that provides transaction isolation\n *\n * @example\n * ```typescript\n * import { test } from 'vitest';\n * import { wrapVitestKyselyTransaction } from '@geekmidas/testkit/kysely';\n * import { db } from './database';\n *\n * // Create isolated test with automatic rollback\n * const isolatedTest = wrapVitestKyselyTransaction(test, {\n *   connection: db,\n * });\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 * });\n *\n * // With fixtures for factories\n * const it = wrapVitestKyselyTransaction<DB, { factory: Factory }>(test, {\n *   connection: db,\n *   fixtures: {\n *     factory: (trx) => new Factory(trx),\n *   },\n * });\n *\n * it('should create user with factory', async ({ trx, factory }) => {\n *   const user = await factory.insert('user', { name: 'Test' });\n *   expect(user.id).toBeDefined();\n * });\n * ```\n */\nexport function wrapVitestKyselyTransaction<\n\tDatabase,\n\tExtended extends Record<string, unknown> = {},\n>(api: TestAPI, options: KyselyTransactionOptions<Database, Extended>) {\n\tconst wrapper = new VitestKyselyTransactionIsolator<Database>(api);\n\n\treturn wrapper.wrapVitestWithTransaction(options);\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, {\n *   connection: db,\n *   setup: createTestTables,\n * });\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\tDatabase,\n\tExtended extends Record<string, unknown>,\n\tT extends ReturnType<TestAPI['extend']> = ReturnType<TestAPI['extend']>,\n>(wrappedTest: T, fixtures: FixtureCreators<Transaction<Database>, Extended>) {\n\treturn baseExtendWithFixtures<Transaction<Database>, Extended, T>(\n\t\twrappedTest,\n\t\tfixtures,\n\t);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+FA,SAAgB,4BAGdA,KAAcC,SAAuD;CACtE,MAAM,UAAU,IAAI,gCAA0C;AAE9D,QAAO,QAAQ,0BAA0B,QAAQ;AACjD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAsDD,SAAgBC,qBAIdC,aAAgBC,UAA4D;AAC7E,QAAO,mBACN,aACA,SACA;AACD"}
+{"version":3,"file":"kysely.mjs","names":["baseExtendWithFixtures"],"sources":["../src/kysely.ts"],"sourcesContent":["import type { Kysely, Transaction } from 'kysely';\nimport type { TestAPI } from 'vitest';\nimport { VitestKyselyTransactionIsolator } from './VitestKyselyTransactionIsolator';\nimport {\n\textendWithFixtures as baseExtendWithFixtures,\n\ttype DatabaseConnection,\n\ttype FixtureCreators,\n\ttype 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 type { ExtractSeedAttrs, FactorySeed } from './Factory';\nexport { KyselyFactory } from './KyselyFactory';\nexport { PostgresKyselyMigrator } from './PostgresKyselyMigrator';\nexport { VitestKyselyTransactionIsolator } from './VitestKyselyTransactionIsolator';\nexport type {\n\tDatabaseFixtures,\n\tExtendedDatabaseFixtures,\n\tFixtureCreators,\n\tTestWithExtendedFixtures,\n\tTransactionWrapperOptions,\n} from './VitestTransactionIsolator';\nexport { IsolationLevel } from './VitestTransactionIsolator';\n\n/**\n * Kysely-specific options for transaction wrapping.\n */\nexport interface KyselyTransactionOptions<\n\tDatabase,\n\tExtended extends Record<string, unknown> = {},\n> {\n\t/** Function that creates or returns a Kysely database instance */\n\tconnection: DatabaseConnection<Kysely<Database>>;\n\t/** Optional setup function to run within the transaction before each test */\n\tsetup?: (trx: Transaction<Database>) => Promise<void>;\n\t/** Transaction isolation level (defaults to REPEATABLE_READ) */\n\tisolationLevel?: IsolationLevel;\n\t/** Additional fixtures that depend on the transaction */\n\tfixtures?: FixtureCreators<Transaction<Database>, Extended>;\n}\n\n// Re-export faker and FakerFactory for type portability in declaration files\nexport { type FakerFactory, faker } 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 * @template Extended - Additional fixtures to provide\n * @param api - The Vitest test API (usually `test` from vitest)\n * @param options - Configuration options for transaction wrapping\n * @returns A wrapped test API that provides transaction isolation\n *\n * @example\n * ```typescript\n * import { test } from 'vitest';\n * import { wrapVitestKyselyTransaction } from '@geekmidas/testkit/kysely';\n * import { db } from './database';\n *\n * // Create isolated test with automatic rollback\n * const isolatedTest = wrapVitestKyselyTransaction(test, {\n *   connection: db,\n * });\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 * });\n *\n * // With fixtures for factories\n * const it = wrapVitestKyselyTransaction<DB, { factory: Factory }>(test, {\n *   connection: db,\n *   fixtures: {\n *     factory: (trx) => new Factory(trx),\n *   },\n * });\n *\n * it('should create user with factory', async ({ trx, factory }) => {\n *   const user = await factory.insert('user', { name: 'Test' });\n *   expect(user.id).toBeDefined();\n * });\n * ```\n */\nexport function wrapVitestKyselyTransaction<\n\tDatabase,\n\tExtended extends Record<string, unknown> = {},\n>(api: TestAPI, options: KyselyTransactionOptions<Database, Extended>) {\n\tconst wrapper = new VitestKyselyTransactionIsolator<Database>(api);\n\n\treturn wrapper.wrapVitestWithTransaction(options);\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, {\n *   connection: db,\n *   setup: createTestTables,\n * });\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\tDatabase,\n\tExtended extends Record<string, unknown>,\n\tT extends ReturnType<TestAPI['extend']> = ReturnType<TestAPI['extend']>,\n>(wrappedTest: T, fixtures: FixtureCreators<Transaction<Database>, Extended>) {\n\treturn baseExtendWithFixtures<Transaction<Database>, Extended, T>(\n\t\twrappedTest,\n\t\tfixtures,\n\t);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+FA,SAAgB,4BAGd,KAAc,SAAuD;CAGtE,OAAO,IAFa,gCAA0C,GAEjD,CAAC,CAAC,0BAA0B,OAAO;AACjD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAsDA,SAAgB,mBAId,aAAgB,UAA4D;CAC7E,OAAOA,qBACN,aACA,QACD;AACD"}

package/dist/logger.cjs

@@ -1,6 +1,5 @@
-const require_chunk = require('./chunk-CUT6urMc.cjs');
-const vitest = require_chunk.__toESM(require("vitest"));
-
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+let vitest = require("vitest");
 //#region src/logger.ts
 /**
 * Creates a mock Logger for testing
@@ -17,7 +16,7 @@ function createMockLogger() {
 	};
 	return logger;
 }
-
 //#endregion
 exports.createMockLogger = createMockLogger;
+
 //# sourceMappingURL=logger.cjs.map

package/dist/logger.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"logger.cjs","names":["logger: Logger"],"sources":["../src/logger.ts"],"sourcesContent":["import type { Logger } from '@geekmidas/logger';\nimport { vi } from 'vitest';\n\n/**\n * Creates a mock Logger for testing\n */\nexport function createMockLogger(): Logger {\n\tconst logger: Logger = {\n\t\tdebug: vi.fn(),\n\t\tinfo: vi.fn(),\n\t\twarn: vi.fn(),\n\t\terror: vi.fn(),\n\t\tfatal: vi.fn(),\n\t\ttrace: vi.fn(),\n\t\tchild: vi.fn(() => logger),\n\t};\n\treturn logger;\n}\n"],"mappings":";;;;;;;AAMA,SAAgB,mBAA2B;CAC1C,MAAMA,SAAiB;EACtB,OAAO,UAAG,IAAI;EACd,MAAM,UAAG,IAAI;EACb,MAAM,UAAG,IAAI;EACb,OAAO,UAAG,IAAI;EACd,OAAO,UAAG,IAAI;EACd,OAAO,UAAG,IAAI;EACd,OAAO,UAAG,GAAG,MAAM,OAAO;CAC1B;AACD,QAAO;AACP"}
+{"version":3,"file":"logger.cjs","names":["vi"],"sources":["../src/logger.ts"],"sourcesContent":["import type { Logger } from '@geekmidas/logger';\nimport { vi } from 'vitest';\n\n/**\n * Creates a mock Logger for testing\n */\nexport function createMockLogger(): Logger {\n\tconst logger: Logger = {\n\t\tdebug: vi.fn(),\n\t\tinfo: vi.fn(),\n\t\twarn: vi.fn(),\n\t\terror: vi.fn(),\n\t\tfatal: vi.fn(),\n\t\ttrace: vi.fn(),\n\t\tchild: vi.fn(() => logger),\n\t};\n\treturn logger;\n}\n"],"mappings":";;;;;;AAMA,SAAgB,mBAA2B;CAC1C,MAAM,SAAiB;EACtB,OAAOA,OAAAA,GAAG,GAAG;EACb,MAAMA,OAAAA,GAAG,GAAG;EACZ,MAAMA,OAAAA,GAAG,GAAG;EACZ,OAAOA,OAAAA,GAAG,GAAG;EACb,OAAOA,OAAAA,GAAG,GAAG;EACb,OAAOA,OAAAA,GAAG,GAAG;EACb,OAAOA,OAAAA,GAAG,SAAS,MAAM;CAC1B;CACA,OAAO;AACR"}

package/dist/logger.d.cts

@@ -1,12 +1,8 @@
 import { Logger } from "@geekmidas/logger";
-
 //#region src/logger.d.ts
-
 /**
  * Creates a mock Logger for testing
  */
-declare function createMockLogger(): Logger;
-//# sourceMappingURL=logger.d.ts.map
+export declare function createMockLogger(): Logger;
 //#endregion
-export { createMockLogger };
 //# sourceMappingURL=logger.d.cts.map

package/dist/logger.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"logger.d.cts","names":[],"sources":["../src/logger.ts"],"sourcesContent":[],"mappings":";;;;;;AAMA;iBAAgB,gBAAA,CAAA,GAAoB"}
+{"version":3,"file":"logger.d.cts","names":[],"sources":["../src/logger.ts"],"mappings":";;;;;wBAMgB,oBAAoB"}

package/dist/logger.d.mts

@@ -1,12 +1,8 @@
 import { Logger } from "@geekmidas/logger";
-
 //#region src/logger.d.ts
-
 /**
  * Creates a mock Logger for testing
  */
-declare function createMockLogger(): Logger;
-//# sourceMappingURL=logger.d.ts.map
+export declare function createMockLogger(): Logger;
 //#endregion
-export { createMockLogger };
 //# sourceMappingURL=logger.d.mts.map

package/dist/logger.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"logger.d.mts","names":[],"sources":["../src/logger.ts"],"sourcesContent":[],"mappings":";;;;;;AAMA;iBAAgB,gBAAA,CAAA,GAAoB"}
+{"version":3,"file":"logger.d.mts","names":[],"sources":["../src/logger.ts"],"mappings":";;;;;wBAMgB,oBAAoB"}

package/dist/logger.mjs

@@ -1,5 +1,4 @@
 import { vi } from "vitest";
-
 //#region src/logger.ts
 /**
 * Creates a mock Logger for testing
@@ -16,7 +15,7 @@ function createMockLogger() {
 	};
 	return logger;
 }
-
 //#endregion
 export { createMockLogger };
+
 //# sourceMappingURL=logger.mjs.map

package/dist/logger.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"logger.mjs","names":["logger: Logger"],"sources":["../src/logger.ts"],"sourcesContent":["import type { Logger } from '@geekmidas/logger';\nimport { vi } from 'vitest';\n\n/**\n * Creates a mock Logger for testing\n */\nexport function createMockLogger(): Logger {\n\tconst logger: Logger = {\n\t\tdebug: vi.fn(),\n\t\tinfo: vi.fn(),\n\t\twarn: vi.fn(),\n\t\terror: vi.fn(),\n\t\tfatal: vi.fn(),\n\t\ttrace: vi.fn(),\n\t\tchild: vi.fn(() => logger),\n\t};\n\treturn logger;\n}\n"],"mappings":";;;;;;AAMA,SAAgB,mBAA2B;CAC1C,MAAMA,SAAiB;EACtB,OAAO,GAAG,IAAI;EACd,MAAM,GAAG,IAAI;EACb,MAAM,GAAG,IAAI;EACb,OAAO,GAAG,IAAI;EACd,OAAO,GAAG,IAAI;EACd,OAAO,GAAG,IAAI;EACd,OAAO,GAAG,GAAG,MAAM,OAAO;CAC1B;AACD,QAAO;AACP"}
+{"version":3,"file":"logger.mjs","names":[],"sources":["../src/logger.ts"],"sourcesContent":["import type { Logger } from '@geekmidas/logger';\nimport { vi } from 'vitest';\n\n/**\n * Creates a mock Logger for testing\n */\nexport function createMockLogger(): Logger {\n\tconst logger: Logger = {\n\t\tdebug: vi.fn(),\n\t\tinfo: vi.fn(),\n\t\twarn: vi.fn(),\n\t\terror: vi.fn(),\n\t\tfatal: vi.fn(),\n\t\ttrace: vi.fn(),\n\t\tchild: vi.fn(() => logger),\n\t};\n\treturn logger;\n}\n"],"mappings":";;;;;AAMA,SAAgB,mBAA2B;CAC1C,MAAM,SAAiB;EACtB,OAAO,GAAG,GAAG;EACb,MAAM,GAAG,GAAG;EACZ,MAAM,GAAG,GAAG;EACZ,OAAO,GAAG,GAAG;EACb,OAAO,GAAG,GAAG;EACb,OAAO,GAAG,GAAG;EACb,OAAO,GAAG,SAAS,MAAM;CAC1B;CACA,OAAO;AACR"}