@geekmidas/testkit 0.0.3 → 0.0.5

package/dist/{PostgresMigrator-BJ2-5A_b.cjs → PostgresMigrator-Bz-tnjB6.cjs}

@@ -1,30 +1,5 @@
-//#region rolldown:runtime
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __commonJS = (cb, mod) => function() {
-	return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
-};
-var __copyProps = (to, from, except, desc) => {
-	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
-		key = keys[i];
-		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
-			get: ((k) => from[k]).bind(null, key),
-			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
-		});
-	}
-	return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
-	value: mod,
-	enumerable: true
-}) : target, mod));
-
-//#endregion
-const pg = __toESM(require("pg"));
+const require_chunk = require('./chunk-CUT6urMc.cjs');
+const pg = require_chunk.__toESM(require("pg"));
 
 //#region src/PostgresMigrator.ts
 async function setupClient(uri) {
@@ -89,16 +64,4 @@ Object.defineProperty(exports, 'PostgresMigrator', {
   get: function () {
     return PostgresMigrator;
   }
-});
-Object.defineProperty(exports, '__commonJS', {
-  enumerable: true,
-  get: function () {
-    return __commonJS;
-  }
-});
-Object.defineProperty(exports, '__toESM', {
-  enumerable: true,
-  get: function () {
-    return __toESM;
-  }
 });

package/dist/PostgresMigrator.cjs

@@ -1,3 +1,3 @@
-const require_PostgresMigrator = require('./PostgresMigrator-BJ2-5A_b.cjs');
+const require_PostgresMigrator = require('./PostgresMigrator-Bz-tnjB6.cjs');
 
 exports.PostgresMigrator = require_PostgresMigrator.PostgresMigrator;

package/dist/PostgresMigrator.mjs

@@ -1,3 +1,3 @@
-import { PostgresMigrator } from "./PostgresMigrator-BKaNTth5.mjs";
+import { PostgresMigrator } from "./PostgresMigrator-CEoRKTdq.mjs";
 
 export { PostgresMigrator };

package/dist/VitestKyselyTransactionIsolator-BS3R-V0I.mjs

@@ -0,0 +1,12 @@
+import { VitestPostgresTransactionIsolator } from "./VitestTransactionIsolator-BjVXqFs6.mjs";
+
+//#region src/VitestKyselyTransactionIsolator.ts
+var VitestKyselyTransactionIsolator = class extends VitestPostgresTransactionIsolator {
+	async transact(conn, level, fn) {
+		const isolationLevel = level.toLocaleLowerCase();
+		await conn.transaction().setIsolationLevel(isolationLevel).execute(fn);
+	}
+};
+
+//#endregion
+export { VitestKyselyTransactionIsolator };

package/dist/VitestKyselyTransactionIsolator-DWSTKIe3.cjs

@@ -0,0 +1,17 @@
+const require_VitestTransactionIsolator = require('./VitestTransactionIsolator-Bx2c4OzK.cjs');
+
+//#region src/VitestKyselyTransactionIsolator.ts
+var VitestKyselyTransactionIsolator = class extends require_VitestTransactionIsolator.VitestPostgresTransactionIsolator {
+	async transact(conn, level, fn) {
+		const isolationLevel = level.toLocaleLowerCase();
+		await conn.transaction().setIsolationLevel(isolationLevel).execute(fn);
+	}
+};
+
+//#endregion
+Object.defineProperty(exports, 'VitestKyselyTransactionIsolator', {
+  enumerable: true,
+  get: function () {
+    return VitestKyselyTransactionIsolator;
+  }
+});

package/dist/VitestKyselyTransactionIsolator.cjs

@@ -0,0 +1,4 @@
+require('./VitestTransactionIsolator-Bx2c4OzK.cjs');
+const require_VitestKyselyTransactionIsolator = require('./VitestKyselyTransactionIsolator-DWSTKIe3.cjs');
+
+exports.VitestKyselyTransactionIsolator = require_VitestKyselyTransactionIsolator.VitestKyselyTransactionIsolator;

package/dist/VitestKyselyTransactionIsolator.mjs

@@ -0,0 +1,4 @@
+import "./VitestTransactionIsolator-BjVXqFs6.mjs";
+import { VitestKyselyTransactionIsolator } from "./VitestKyselyTransactionIsolator-BS3R-V0I.mjs";
+
+export { VitestKyselyTransactionIsolator };

package/dist/VitestTransactionIsolator-BjVXqFs6.mjs

@@ -0,0 +1,40 @@
+import { test } from "vitest";
+
+//#region src/VitestTransactionIsolator.ts
+let IsolationLevel = /* @__PURE__ */ function(IsolationLevel$1) {
+	IsolationLevel$1["READ_UNCOMMITTED"] = "READ UNCOMMITTED";
+	IsolationLevel$1["READ_COMMITTED"] = "READ COMMITTED";
+	IsolationLevel$1["REPEATABLE_READ"] = "REPEATABLE READ";
+	IsolationLevel$1["SERIALIZABLE"] = "SERIALIZABLE";
+	return IsolationLevel$1;
+}({});
+var VitestPostgresTransactionIsolator = class {
+	wrapVitestWithTransaction(conn, setup, level = IsolationLevel.REPEATABLE_READ) {
+		return test.extend({ trx: async ({}, use) => {
+			class TestRollback extends Error {
+				constructor() {
+					super("Test rollback");
+					this.name = "TestRollback";
+				}
+			}
+			let testError;
+			try {
+				await this.transact(conn, level, async (transaction) => {
+					try {
+						await setup?.(transaction);
+						await use(transaction);
+					} catch (error) {
+						testError = error;
+					}
+					throw new TestRollback();
+				});
+			} catch (error) {
+				if (!(error instanceof TestRollback)) throw error;
+				if (testError) throw testError;
+			}
+		} });
+	}
+};
+
+//#endregion
+export { IsolationLevel, VitestPostgresTransactionIsolator };

package/dist/VitestTransactionIsolator-Bx2c4OzK.cjs

@@ -0,0 +1,52 @@
+const require_chunk = require('./chunk-CUT6urMc.cjs');
+const vitest = require_chunk.__toESM(require("vitest"));
+
+//#region src/VitestTransactionIsolator.ts
+let IsolationLevel = /* @__PURE__ */ function(IsolationLevel$1) {
+	IsolationLevel$1["READ_UNCOMMITTED"] = "READ UNCOMMITTED";
+	IsolationLevel$1["READ_COMMITTED"] = "READ COMMITTED";
+	IsolationLevel$1["REPEATABLE_READ"] = "REPEATABLE READ";
+	IsolationLevel$1["SERIALIZABLE"] = "SERIALIZABLE";
+	return IsolationLevel$1;
+}({});
+var VitestPostgresTransactionIsolator = class {
+	wrapVitestWithTransaction(conn, setup, level = IsolationLevel.REPEATABLE_READ) {
+		return vitest.test.extend({ trx: async ({}, use) => {
+			class TestRollback extends Error {
+				constructor() {
+					super("Test rollback");
+					this.name = "TestRollback";
+				}
+			}
+			let testError;
+			try {
+				await this.transact(conn, level, async (transaction) => {
+					try {
+						await setup?.(transaction);
+						await use(transaction);
+					} catch (error) {
+						testError = error;
+					}
+					throw new TestRollback();
+				});
+			} catch (error) {
+				if (!(error instanceof TestRollback)) throw error;
+				if (testError) throw testError;
+			}
+		} });
+	}
+};
+
+//#endregion
+Object.defineProperty(exports, 'IsolationLevel', {
+  enumerable: true,
+  get: function () {
+    return IsolationLevel;
+  }
+});
+Object.defineProperty(exports, 'VitestPostgresTransactionIsolator', {
+  enumerable: true,
+  get: function () {
+    return VitestPostgresTransactionIsolator;
+  }
+});

package/dist/VitestTransactionIsolator.cjs

@@ -0,0 +1,4 @@
+const require_VitestTransactionIsolator = require('./VitestTransactionIsolator-Bx2c4OzK.cjs');
+
+exports.IsolationLevel = require_VitestTransactionIsolator.IsolationLevel;
+exports.VitestPostgresTransactionIsolator = require_VitestTransactionIsolator.VitestPostgresTransactionIsolator;

package/dist/VitestTransactionIsolator.mjs

@@ -0,0 +1,3 @@
+import { IsolationLevel, VitestPostgresTransactionIsolator } from "./VitestTransactionIsolator-BjVXqFs6.mjs";
+
+export { IsolationLevel, VitestPostgresTransactionIsolator };

package/dist/__tests__/Factory.spec.cjs

@@ -0,0 +1,139 @@
+const require_chunk = require('../chunk-CUT6urMc.cjs');
+const require_Factory = require('../Factory-DREHoms3.cjs');
+const vitest = require_chunk.__toESM(require("vitest"));
+
+//#region src/__tests__/Factory.spec.ts
+var TestFactory = class extends require_Factory.Factory {
+	async insert(builderName, attrs) {
+		return Promise.resolve({
+			id: 1,
+			...attrs
+		});
+	}
+	async insertMany(count, builderName, attrs) {
+		const results = [];
+		for (let i = 0; i < count; i++) {
+			const newAttrs = typeof attrs === "function" ? attrs(i) : attrs;
+			results.push(await this.insert(builderName, newAttrs));
+		}
+		return results;
+	}
+	seed(seedName, attrs) {
+		return Promise.resolve({
+			seedResult: true,
+			...attrs
+		});
+	}
+};
+(0, vitest.describe)("Factory", () => {
+	(0, vitest.describe)("abstract class functionality", () => {
+		(0, vitest.it)("should be instantiable through concrete implementation", () => {
+			const factory = new TestFactory();
+			(0, vitest.expect)(factory).toBeInstanceOf(require_Factory.Factory);
+			(0, vitest.expect)(factory).toBeInstanceOf(TestFactory);
+		});
+		(0, vitest.it)("should have abstract methods defined", () => {
+			const factory = new TestFactory();
+			(0, vitest.expect)(typeof factory.insert).toBe("function");
+			(0, vitest.expect)(typeof factory.insertMany).toBe("function");
+			(0, vitest.expect)(typeof factory.seed).toBe("function");
+		});
+	});
+	(0, vitest.describe)("createSeed static method", () => {
+		(0, vitest.it)("should return the seed function unchanged", () => {
+			const seedFn = async (attrs, factory, db) => {
+				return {
+					id: 1,
+					name: "test"
+				};
+			};
+			const result = require_Factory.Factory.createSeed(seedFn);
+			(0, vitest.expect)(result).toBe(seedFn);
+			(0, vitest.expect)(typeof result).toBe("function");
+		});
+		(0, vitest.it)("should work with different seed function signatures", () => {
+			const simpleSeed = () => Promise.resolve({ simple: true });
+			const complexSeed = async (attrs, factory, db) => {
+				return {
+					name: attrs.name,
+					created: true
+				};
+			};
+			const result1 = require_Factory.Factory.createSeed(simpleSeed);
+			const result2 = require_Factory.Factory.createSeed(complexSeed);
+			(0, vitest.expect)(result1).toBe(simpleSeed);
+			(0, vitest.expect)(result2).toBe(complexSeed);
+		});
+	});
+	(0, vitest.describe)("concrete implementation behavior", () => {
+		let factory;
+		(0, vitest.beforeEach)(() => {
+			factory = new TestFactory();
+		});
+		(0, vitest.it)("should implement insert method", async () => {
+			const result = await factory.insert("testBuilder", { name: "test" });
+			(0, vitest.expect)(result).toEqual({
+				id: 1,
+				name: "test"
+			});
+		});
+		(0, vitest.it)("should implement insertMany method", async () => {
+			const results = await factory.insertMany(3, "testBuilder", { name: "test" });
+			(0, vitest.expect)(results).toHaveLength(3);
+			(0, vitest.expect)(results[0]).toEqual({
+				id: 1,
+				name: "test"
+			});
+		});
+		(0, vitest.it)("should implement insertMany with function attributes", async () => {
+			const results = await factory.insertMany(2, "testBuilder", (idx) => ({ name: `test${idx}` }));
+			(0, vitest.expect)(results).toHaveLength(2);
+			(0, vitest.expect)(results[0]).toEqual({
+				id: 1,
+				name: "test0"
+			});
+			(0, vitest.expect)(results[1]).toEqual({
+				id: 1,
+				name: "test1"
+			});
+		});
+		(0, vitest.it)("should implement seed method", async () => {
+			const result = await factory.seed("testSeed", { custom: "value" });
+			(0, vitest.expect)(result).toEqual({
+				seedResult: true,
+				custom: "value"
+			});
+		});
+	});
+	(0, vitest.describe)("type definitions", () => {
+		(0, vitest.it)("should properly type MixedFactoryBuilder", () => {
+			const syncBuilder = (attrs, factory, db) => ({ sync: true });
+			const asyncBuilder = async (attrs, factory, db) => ({ async: true });
+			(0, vitest.expect)(typeof syncBuilder).toBe("function");
+			(0, vitest.expect)(typeof asyncBuilder).toBe("function");
+		});
+		(0, vitest.it)("should properly type FactorySeed", () => {
+			const seed = async (attrs, factory, db) => ({ seeded: true });
+			(0, vitest.expect)(typeof seed).toBe("function");
+		});
+	});
+});
+(0, vitest.describe)("Factory types", () => {
+	(0, vitest.it)("should export MixedFactoryBuilder type", () => {
+		const builder = (attrs, factory, db) => {
+			return {
+				id: 1,
+				name: attrs.name
+			};
+		};
+		(0, vitest.expect)(typeof builder).toBe("function");
+	});
+	(0, vitest.it)("should export FactorySeed type", () => {
+		const seed = async (attrs, factory, db) => {
+			return { created: attrs.count };
+		};
+		(0, vitest.expect)(typeof seed).toBe("function");
+	});
+});
+
+//#endregion

package/dist/__tests__/Factory.spec.mjs

@@ -0,0 +1,138 @@
+import { Factory } from "../Factory-DlzMkMzb.mjs";
+import { beforeEach, describe, expect, it } from "vitest";
+
+//#region src/__tests__/Factory.spec.ts
+var TestFactory = class extends Factory {
+	async insert(builderName, attrs) {
+		return Promise.resolve({
+			id: 1,
+			...attrs
+		});
+	}
+	async insertMany(count, builderName, attrs) {
+		const results = [];
+		for (let i = 0; i < count; i++) {
+			const newAttrs = typeof attrs === "function" ? attrs(i) : attrs;
+			results.push(await this.insert(builderName, newAttrs));
+		}
+		return results;
+	}
+	seed(seedName, attrs) {
+		return Promise.resolve({
+			seedResult: true,
+			...attrs
+		});
+	}
+};
+describe("Factory", () => {
+	describe("abstract class functionality", () => {
+		it("should be instantiable through concrete implementation", () => {
+			const factory = new TestFactory();
+			expect(factory).toBeInstanceOf(Factory);
+			expect(factory).toBeInstanceOf(TestFactory);
+		});
+		it("should have abstract methods defined", () => {
+			const factory = new TestFactory();
+			expect(typeof factory.insert).toBe("function");
+			expect(typeof factory.insertMany).toBe("function");
+			expect(typeof factory.seed).toBe("function");
+		});
+	});
+	describe("createSeed static method", () => {
+		it("should return the seed function unchanged", () => {
+			const seedFn = async (attrs, factory, db) => {
+				return {
+					id: 1,
+					name: "test"
+				};
+			};
+			const result = Factory.createSeed(seedFn);
+			expect(result).toBe(seedFn);
+			expect(typeof result).toBe("function");
+		});
+		it("should work with different seed function signatures", () => {
+			const simpleSeed = () => Promise.resolve({ simple: true });
+			const complexSeed = async (attrs, factory, db) => {
+				return {
+					name: attrs.name,
+					created: true
+				};
+			};
+			const result1 = Factory.createSeed(simpleSeed);
+			const result2 = Factory.createSeed(complexSeed);
+			expect(result1).toBe(simpleSeed);
+			expect(result2).toBe(complexSeed);
+		});
+	});
+	describe("concrete implementation behavior", () => {
+		let factory;
+		beforeEach(() => {
+			factory = new TestFactory();
+		});
+		it("should implement insert method", async () => {
+			const result = await factory.insert("testBuilder", { name: "test" });
+			expect(result).toEqual({
+				id: 1,
+				name: "test"
+			});
+		});
+		it("should implement insertMany method", async () => {
+			const results = await factory.insertMany(3, "testBuilder", { name: "test" });
+			expect(results).toHaveLength(3);
+			expect(results[0]).toEqual({
+				id: 1,
+				name: "test"
+			});
+		});
+		it("should implement insertMany with function attributes", async () => {
+			const results = await factory.insertMany(2, "testBuilder", (idx) => ({ name: `test${idx}` }));
+			expect(results).toHaveLength(2);
+			expect(results[0]).toEqual({
+				id: 1,
+				name: "test0"
+			});
+			expect(results[1]).toEqual({
+				id: 1,
+				name: "test1"
+			});
+		});
+		it("should implement seed method", async () => {
+			const result = await factory.seed("testSeed", { custom: "value" });
+			expect(result).toEqual({
+				seedResult: true,
+				custom: "value"
+			});
+		});
+	});
+	describe("type definitions", () => {
+		it("should properly type MixedFactoryBuilder", () => {
+			const syncBuilder = (attrs, factory, db) => ({ sync: true });
+			const asyncBuilder = async (attrs, factory, db) => ({ async: true });
+			expect(typeof syncBuilder).toBe("function");
+			expect(typeof asyncBuilder).toBe("function");
+		});
+		it("should properly type FactorySeed", () => {
+			const seed = async (attrs, factory, db) => ({ seeded: true });
+			expect(typeof seed).toBe("function");
+		});
+	});
+});
+describe("Factory types", () => {
+	it("should export MixedFactoryBuilder type", () => {
+		const builder = (attrs, factory, db) => {
+			return {
+				id: 1,
+				name: attrs.name
+			};
+		};
+		expect(typeof builder).toBe("function");
+	});
+	it("should export FactorySeed type", () => {
+		const seed = async (attrs, factory, db) => {
+			return { created: attrs.count };
+		};
+		expect(typeof seed).toBe("function");
+	});
+});
+
+//#endregion