@geekmidas/testkit 0.0.8 → 0.0.9

package/dist/__tests__/PostgresObjectionMigrator.spec.mjs

@@ -0,0 +1,431 @@
+import "../PostgresMigrator-BzqksJcW.mjs";
+import { PostgresObjectionMigrator } from "../PostgresObjectionMigrator-DydSgYFv.mjs";
+import { createTestDatabase } from "../helpers-BEmjyUVE.mjs";
+import { Client } from "pg";
+import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, it, vi } from "vitest";
+import knex from "knex";
+import { promises } from "node:fs";
+import path from "node:path";
+
+//#region src/__tests__/PostgresObjectionMigrator.spec.ts
+describe("PostgresObjectionMigrator", () => {
+	let testDbName;
+	let cleanupDb;
+	let consoleSpy;
+	let consoleErrorSpy;
+	let testMigrationsDir;
+	beforeAll(async () => {
+		testDbName = `test_postgres_objection_migrator_${Date.now()}`;
+		cleanupDb = await createTestDatabase(testDbName);
+		testMigrationsDir = path.join(process.cwd(), "test-migrations", Date.now().toString());
+		await promises.mkdir(testMigrationsDir, { recursive: true });
+		await promises.writeFile(path.join(testMigrationsDir, "001_create_users.js"), `
+exports.up = function(knex) {
+  return knex.schema.createTable('users', function(table) {
+    table.increments('id').primary();
+    table.string('name');
+    table.string('email').unique();
+    table.timestamps(true, true);
+  });
+};
+
+exports.down = function(knex) {
+  return knex.schema.dropTable('users');
+};
+`);
+		await promises.writeFile(path.join(testMigrationsDir, "002_create_posts.js"), `
+exports.up = function(knex) {
+  return knex.schema.createTable('posts', function(table) {
+    table.increments('id').primary();
+    table.string('title');
+    table.text('content');
+    table.integer('user_id').unsigned().references('id').inTable('users');
+    table.timestamps(true, true);
+  });
+};
+
+exports.down = function(knex) {
+  return knex.schema.dropTable('posts');
+};
+`);
+	});
+	beforeEach(() => {
+		consoleSpy = vi.spyOn(console, "log").mockImplementation(() => {});
+		consoleErrorSpy = vi.spyOn(console, "error").mockImplementation(() => {});
+	});
+	afterEach(() => {
+		consoleSpy.mockRestore();
+		consoleErrorSpy.mockRestore();
+	});
+	afterAll(async () => {
+		await cleanupDb();
+		await promises.rm(testMigrationsDir, {
+			recursive: true,
+			force: true
+		});
+	});
+	describe("constructor", () => {
+		it("should create a PostgresObjectionMigrator instance", () => {
+			const knexInstance = knex({
+				client: "pg",
+				connection: `postgresql://geekmidas:geekmidas@localhost:5432/${testDbName}`
+			});
+			const migrator = new PostgresObjectionMigrator({
+				uri: `postgresql://geekmidas:geekmidas@localhost:5432/${testDbName}`,
+				knex: knexInstance
+			});
+			expect(migrator).toBeInstanceOf(PostgresObjectionMigrator);
+			knexInstance.destroy();
+		});
+	});
+	describe("migrate method", () => {
+		it("should run migrations to latest", async () => {
+			const newDbName = `test_migrate_${Date.now()}`;
+			const uri = `postgresql://geekmidas:geekmidas@localhost:5432/${newDbName}`;
+			const knexInstance = knex({
+				client: "pg",
+				connection: uri,
+				migrations: { directory: testMigrationsDir }
+			});
+			const migrator = new PostgresObjectionMigrator({
+				uri,
+				knex: knexInstance
+			});
+			const cleanup = await migrator.start();
+			expect(consoleSpy).toHaveBeenCalledWith(`Migrating database: ${newDbName}`);
+			expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining("Applied batch"));
+			const verifyClient = new Client({
+				host: "localhost",
+				port: 5432,
+				user: "geekmidas",
+				password: "geekmidas",
+				database: newDbName
+			});
+			await verifyClient.connect();
+			const tablesResult = await verifyClient.query(`
+        SELECT table_name FROM information_schema.tables 
+        WHERE table_schema = 'public' 
+        AND table_name IN ('users', 'posts')
+        ORDER BY table_name
+      `);
+			expect(tablesResult.rows).toEqual([{ table_name: "posts" }, { table_name: "users" }]);
+			await verifyClient.end();
+			await cleanup();
+		});
+		it("should handle no pending migrations", async () => {
+			const newDbName = `test_no_pending_${Date.now()}`;
+			const uri = `postgresql://geekmidas:geekmidas@localhost:5432/${newDbName}`;
+			const knexInstance1 = knex({
+				client: "pg",
+				connection: uri,
+				migrations: { directory: testMigrationsDir }
+			});
+			const migrator1 = new PostgresObjectionMigrator({
+				uri,
+				knex: knexInstance1
+			});
+			const cleanup = await migrator1.start();
+			consoleSpy.mockClear();
+			const knexInstance2 = knex({
+				client: "pg",
+				connection: uri,
+				migrations: { directory: testMigrationsDir }
+			});
+			const migrator2 = new PostgresObjectionMigrator({
+				uri,
+				knex: knexInstance2
+			});
+			await migrator2.migrate();
+			expect(consoleSpy).toHaveBeenCalledWith("No pending migrations to apply");
+			await cleanup();
+		});
+		it("should handle migration errors", async () => {
+			const newDbName = `test_migration_error_${Date.now()}`;
+			const uri = `postgresql://geekmidas:geekmidas@localhost:5432/${newDbName}`;
+			const badMigrationsDir = path.join(process.cwd(), "bad-migrations", Date.now().toString());
+			await promises.mkdir(badMigrationsDir, { recursive: true });
+			await promises.writeFile(path.join(badMigrationsDir, "001_bad_migration.js"), `
+exports.up = function(knex) {
+  throw new Error('Migration failed on purpose');
+};
+
+exports.down = function(knex) {
+  return Promise.resolve();
+};
+`);
+			const knexInstance = knex({
+				client: "pg",
+				connection: uri,
+				migrations: { directory: badMigrationsDir }
+			});
+			const migrator = new PostgresObjectionMigrator({
+				uri,
+				knex: knexInstance
+			});
+			await expect(migrator.start()).rejects.toThrow("Migration failed on purpose");
+			expect(consoleErrorSpy).toHaveBeenCalledWith("Failed to apply migrations:", expect.any(Error));
+			await promises.rm(badMigrationsDir, {
+				recursive: true,
+				force: true
+			});
+			const cleanupClient = new Client({
+				host: "localhost",
+				port: 5432,
+				user: "geekmidas",
+				password: "geekmidas",
+				database: "postgres"
+			});
+			await cleanupClient.connect();
+			await cleanupClient.query(`DROP DATABASE IF EXISTS "${newDbName}"`);
+			await cleanupClient.end();
+		});
+		it("should destroy knex connection after migration", async () => {
+			const newDbName = `test_destroy_${Date.now()}`;
+			const uri = `postgresql://geekmidas:geekmidas@localhost:5432/${newDbName}`;
+			const knexInstance = knex({
+				client: "pg",
+				connection: uri,
+				migrations: { directory: testMigrationsDir }
+			});
+			const destroySpy = vi.spyOn(knexInstance, "destroy");
+			const migrator = new PostgresObjectionMigrator({
+				uri,
+				knex: knexInstance
+			});
+			const cleanup = await migrator.start();
+			expect(destroySpy).toHaveBeenCalled();
+			await cleanup();
+		});
+	});
+	describe("rollback method", () => {
+		it("should rollback last migration batch", async () => {
+			const newDbName = `test_rollback_${Date.now()}`;
+			const uri = `postgresql://geekmidas:geekmidas@localhost:5432/${newDbName}`;
+			const knexInstance1 = knex({
+				client: "pg",
+				connection: uri,
+				migrations: { directory: testMigrationsDir }
+			});
+			const migrator1 = new PostgresObjectionMigrator({
+				uri,
+				knex: knexInstance1
+			});
+			const cleanup = await migrator1.start();
+			consoleSpy.mockClear();
+			const knexInstance2 = knex({
+				client: "pg",
+				connection: uri,
+				migrations: { directory: testMigrationsDir }
+			});
+			const migrator2 = new PostgresObjectionMigrator({
+				uri,
+				knex: knexInstance2
+			});
+			await migrator2.rollback();
+			expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining("Rolled back batch"));
+			const verifyClient = new Client({
+				host: "localhost",
+				port: 5432,
+				user: "geekmidas",
+				password: "geekmidas",
+				database: newDbName
+			});
+			await verifyClient.connect();
+			const tablesResult = await verifyClient.query(`
+        SELECT table_name FROM information_schema.tables 
+        WHERE table_schema = 'public' 
+        AND table_name IN ('users', 'posts')
+      `);
+			expect(tablesResult.rows).toEqual([]);
+			await verifyClient.end();
+			await cleanup();
+		});
+		it("should handle no migrations to rollback", async () => {
+			const newDbName = `test_no_rollback_${Date.now()}`;
+			const uri = `postgresql://geekmidas:geekmidas@localhost:5432/${newDbName}`;
+			const createClient = new Client({
+				host: "localhost",
+				port: 5432,
+				user: "geekmidas",
+				password: "geekmidas",
+				database: "postgres"
+			});
+			await createClient.connect();
+			await createClient.query(`CREATE DATABASE "${newDbName}"`);
+			await createClient.end();
+			const knexInstance = knex({
+				client: "pg",
+				connection: uri,
+				migrations: { directory: testMigrationsDir }
+			});
+			const migrator = new PostgresObjectionMigrator({
+				uri,
+				knex: knexInstance
+			});
+			await migrator.rollback();
+			expect(consoleSpy).toHaveBeenCalledWith("No migrations to rollback");
+			const cleanupClient = new Client({
+				host: "localhost",
+				port: 5432,
+				user: "geekmidas",
+				password: "geekmidas",
+				database: "postgres"
+			});
+			await cleanupClient.connect();
+			await cleanupClient.query(`DROP DATABASE IF EXISTS "${newDbName}"`);
+			await cleanupClient.end();
+		});
+		it("should handle rollback errors", async () => {
+			const newDbName = `test_rollback_error_${Date.now()}`;
+			const uri = `postgresql://geekmidas:geekmidas@localhost:5432/${newDbName}`;
+			const knexInstance = knex({
+				client: "pg",
+				connection: uri,
+				migrations: { directory: testMigrationsDir }
+			});
+			const migrator = new PostgresObjectionMigrator({
+				uri,
+				knex: knexInstance
+			});
+			await expect(migrator.rollback()).rejects.toThrow();
+			expect(consoleErrorSpy).toHaveBeenCalledWith("Failed to rollback migrations:", expect.any(Error));
+			await knexInstance.destroy();
+		});
+	});
+	describe("status method", () => {
+		it("should return migration status", async () => {
+			const newDbName = `test_status_${Date.now()}`;
+			const uri = `postgresql://geekmidas:geekmidas@localhost:5432/${newDbName}`;
+			const knexInstance1 = knex({
+				client: "pg",
+				connection: uri,
+				migrations: { directory: testMigrationsDir }
+			});
+			const migrator1 = new PostgresObjectionMigrator({
+				uri,
+				knex: knexInstance1
+			});
+			const cleanup = await migrator1.start();
+			const knexInstance2 = knex({
+				client: "pg",
+				connection: uri,
+				migrations: { directory: testMigrationsDir }
+			});
+			const migrator2 = new PostgresObjectionMigrator({
+				uri,
+				knex: knexInstance2
+			});
+			const status = await migrator2.status();
+			expect(status).toHaveProperty("completed");
+			expect(status).toHaveProperty("pending");
+			expect(Array.isArray(status.completed)).toBe(true);
+			expect(Array.isArray(status.pending)).toBe(true);
+			await cleanup();
+		});
+		it("should destroy connection after getting status", async () => {
+			const newDbName = `test_status_destroy_${Date.now()}`;
+			const uri = `postgresql://geekmidas:geekmidas@localhost:5432/${newDbName}`;
+			const knexInstance = knex({
+				client: "pg",
+				connection: uri,
+				migrations: { directory: testMigrationsDir }
+			});
+			const destroySpy = vi.spyOn(knexInstance, "destroy");
+			const migrator = new PostgresObjectionMigrator({
+				uri,
+				knex: knexInstance
+			});
+			const createClient = new Client({
+				host: "localhost",
+				port: 5432,
+				user: "geekmidas",
+				password: "geekmidas",
+				database: "postgres"
+			});
+			await createClient.connect();
+			await createClient.query(`CREATE DATABASE "${newDbName}"`);
+			await createClient.end();
+			await migrator.status();
+			expect(destroySpy).toHaveBeenCalled();
+			const cleanupClient = new Client({
+				host: "localhost",
+				port: 5432,
+				user: "geekmidas",
+				password: "geekmidas",
+				database: "postgres"
+			});
+			await cleanupClient.connect();
+			await cleanupClient.query(`DROP DATABASE IF EXISTS "${newDbName}"`);
+			await cleanupClient.end();
+		});
+	});
+	describe("integration scenarios", () => {
+		it("should handle complete workflow with complex migrations", async () => {
+			const integrationDbName = `test_integration_${Date.now()}`;
+			const uri = `postgresql://geekmidas:geekmidas@localhost:5432/${integrationDbName}`;
+			const knexInstance = knex({
+				client: "pg",
+				connection: uri,
+				migrations: { directory: testMigrationsDir }
+			});
+			const migrator = new PostgresObjectionMigrator({
+				uri,
+				knex: knexInstance
+			});
+			const cleanup = await migrator.start();
+			const testClient = new Client({
+				host: "localhost",
+				port: 5432,
+				user: "geekmidas",
+				password: "geekmidas",
+				database: integrationDbName
+			});
+			await testClient.connect();
+			const userResult = await testClient.query(`INSERT INTO users (name, email) VALUES ($1, $2) RETURNING id`, ["Test User", "test@example.com"]);
+			const userId = userResult.rows[0].id;
+			await testClient.query(`INSERT INTO posts (title, content, user_id) VALUES ($1, $2, $3)`, [
+				"Test Post",
+				"This is a test post",
+				userId
+			]);
+			const postResult = await testClient.query(`SELECT * FROM posts WHERE user_id = $1`, [userId]);
+			expect(postResult.rowCount).toBe(1);
+			expect(postResult.rows[0].title).toBe("Test Post");
+			await testClient.end();
+			await cleanup();
+		});
+		it("should work with transaction-based tests", async () => {
+			const transactionDbName = `test_transaction_${Date.now()}`;
+			const uri = `postgresql://geekmidas:geekmidas@localhost:5432/${transactionDbName}`;
+			const knexInstance = knex({
+				client: "pg",
+				connection: uri,
+				migrations: { directory: testMigrationsDir }
+			});
+			const migrator = new PostgresObjectionMigrator({
+				uri,
+				knex: knexInstance
+			});
+			const cleanup = await migrator.start();
+			const testKnex = knex({
+				client: "pg",
+				connection: uri
+			});
+			await testKnex.transaction(async (trx) => {
+				await trx("users").insert({
+					name: "Transaction User",
+					email: "trx@example.com"
+				});
+				const users$1 = await trx("users").select("*");
+				expect(users$1.length).toBeGreaterThan(0);
+				throw new Error("Rollback transaction");
+			}).catch(() => {});
+			const users = await testKnex("users").select("*");
+			expect(users.length).toBe(0);
+			await testKnex.destroy();
+			await cleanup();
+		});
+	});
+});
+
+//#endregion

package/dist/__tests__/VitestObjectionTransactionIsolator.spec.cjs

@@ -0,0 +1,130 @@
+const require_chunk = require('../chunk-CUT6urMc.cjs');
+require('../Factory-WMhTNZ9S.cjs');
+require('../ObjectionFactory-C47B03Ot.cjs');
+require('../PostgresMigrator-BtAWdLss.cjs');
+require('../PostgresObjectionMigrator-B88aTT0m.cjs');
+require('../VitestTransactionIsolator-CruLTRRi.cjs');
+require('../VitestObjectionTransactionIsolator-DyqLp_in.cjs');
+const require_objection = require('../objection-CCD8fMLj.cjs');
+const require_helpers = require('../helpers-CNMBePuj.cjs');
+const vitest = require_chunk.__toESM(require("vitest"));
+const objection = require_chunk.__toESM(require("objection"));
+
+//#region src/__tests__/VitestObjectionTransactionIsolator.spec.ts
+var User = class extends objection.Model {
+	static get tableName() {
+		return "users";
+	}
+	id;
+	name;
+	email;
+	role;
+	createdAt;
+	updatedAt;
+	static get relationMappings() {
+		return {
+			posts: {
+				relation: objection.Model.HasManyRelation,
+				modelClass: Post,
+				join: {
+					from: "users.id",
+					to: "posts.user_id"
+				}
+			},
+			comments: {
+				relation: objection.Model.HasManyRelation,
+				modelClass: Comment,
+				join: {
+					from: "users.id",
+					to: "comments.user_id"
+				}
+			}
+		};
+	}
+};
+var Post = class extends objection.Model {
+	static get tableName() {
+		return "posts";
+	}
+	id;
+	title;
+	content;
+	userId;
+	published;
+	createdAt;
+	updatedAt;
+	static get relationMappings() {
+		return {
+			user: {
+				relation: objection.Model.BelongsToOneRelation,
+				modelClass: User,
+				join: {
+					from: "posts.user_id",
+					to: "users.id"
+				}
+			},
+			comments: {
+				relation: objection.Model.HasManyRelation,
+				modelClass: Comment,
+				join: {
+					from: "posts.id",
+					to: "comments.post_id"
+				}
+			}
+		};
+	}
+};
+var Comment = class extends objection.Model {
+	static get tableName() {
+		return "comments";
+	}
+	id;
+	content;
+	postId;
+	userId;
+	createdAt;
+	static get relationMappings() {
+		return {
+			post: {
+				relation: objection.Model.BelongsToOneRelation,
+				modelClass: Post,
+				join: {
+					from: "comments.post_id",
+					to: "posts.id"
+				}
+			},
+			user: {
+				relation: objection.Model.BelongsToOneRelation,
+				modelClass: User,
+				join: {
+					from: "comments.user_id",
+					to: "users.id"
+				}
+			}
+		};
+	}
+};
+const knex = require_helpers.createKnexDb();
+objection.Model.knex(knex);
+const it = require_objection.wrapVitestObjectionTransaction(vitest.it, knex, async (trx) => {
+	await require_helpers.createTestTablesKnex(trx);
+});
+(0, vitest.describe)("VitestObjectionTransactionIsolator", () => {
+	(0, vitest.describe)("Transaction Isolation", () => {
+		it("should rollback data after test completes", async ({ trx }) => {
+			const user = await User.query(trx).insert({
+				name: "Test User",
+				email: "test@example.com",
+				role: "user"
+			});
+			(0, vitest.expect)(user).toBeDefined();
+			(0, vitest.expect)(user.id).toBeDefined();
+			(0, vitest.expect)(user.name).toBe("Test User");
+			const foundUser = await User.query(trx).findById(user.id);
+			(0, vitest.expect)(foundUser).toBeDefined();
+			(0, vitest.expect)(foundUser?.email).toBe(user.email);
+		});
+	});
+});
+
+//#endregion

package/dist/__tests__/VitestObjectionTransactionIsolator.spec.mjs

@@ -0,0 +1,129 @@
+import "../Factory-z2m01hMj.mjs";
+import "../ObjectionFactory-89p-FFEw.mjs";
+import "../PostgresMigrator-BzqksJcW.mjs";
+import "../PostgresObjectionMigrator-DydSgYFv.mjs";
+import "../VitestTransactionIsolator-BWwK-ca6.mjs";
+import "../VitestObjectionTransactionIsolator-BPoLUFop.mjs";
+import { wrapVitestObjectionTransaction } from "../objection-lsMgM5gP.mjs";
+import { createKnexDb, createTestTablesKnex } from "../helpers-BEmjyUVE.mjs";
+import { describe, expect, it } from "vitest";
+import { Model } from "objection";
+
+//#region src/__tests__/VitestObjectionTransactionIsolator.spec.ts
+var User = class extends Model {
+	static get tableName() {
+		return "users";
+	}
+	id;
+	name;
+	email;
+	role;
+	createdAt;
+	updatedAt;
+	static get relationMappings() {
+		return {
+			posts: {
+				relation: Model.HasManyRelation,
+				modelClass: Post,
+				join: {
+					from: "users.id",
+					to: "posts.user_id"
+				}
+			},
+			comments: {
+				relation: Model.HasManyRelation,
+				modelClass: Comment,
+				join: {
+					from: "users.id",
+					to: "comments.user_id"
+				}
+			}
+		};
+	}
+};
+var Post = class extends Model {
+	static get tableName() {
+		return "posts";
+	}
+	id;
+	title;
+	content;
+	userId;
+	published;
+	createdAt;
+	updatedAt;
+	static get relationMappings() {
+		return {
+			user: {
+				relation: Model.BelongsToOneRelation,
+				modelClass: User,
+				join: {
+					from: "posts.user_id",
+					to: "users.id"
+				}
+			},
+			comments: {
+				relation: Model.HasManyRelation,
+				modelClass: Comment,
+				join: {
+					from: "posts.id",
+					to: "comments.post_id"
+				}
+			}
+		};
+	}
+};
+var Comment = class extends Model {
+	static get tableName() {
+		return "comments";
+	}
+	id;
+	content;
+	postId;
+	userId;
+	createdAt;
+	static get relationMappings() {
+		return {
+			post: {
+				relation: Model.BelongsToOneRelation,
+				modelClass: Post,
+				join: {
+					from: "comments.post_id",
+					to: "posts.id"
+				}
+			},
+			user: {
+				relation: Model.BelongsToOneRelation,
+				modelClass: User,
+				join: {
+					from: "comments.user_id",
+					to: "users.id"
+				}
+			}
+		};
+	}
+};
+const knex = createKnexDb();
+Model.knex(knex);
+const it$1 = wrapVitestObjectionTransaction(it, knex, async (trx) => {
+	await createTestTablesKnex(trx);
+});
+describe("VitestObjectionTransactionIsolator", () => {
+	describe("Transaction Isolation", () => {
+		it$1("should rollback data after test completes", async ({ trx }) => {
+			const user = await User.query(trx).insert({
+				name: "Test User",
+				email: "test@example.com",
+				role: "user"
+			});
+			expect(user).toBeDefined();
+			expect(user.id).toBeDefined();
+			expect(user.name).toBe("Test User");
+			const foundUser = await User.query(trx).findById(user.id);
+			expect(foundUser).toBeDefined();
+			expect(foundUser?.email).toBe(user.email);
+		});
+	});
+});
+
+//#endregion

package/dist/__tests__/integration.spec.cjs

@@ -4,11 +4,11 @@ require('../faker-SMN4ira4.cjs');
 const require_KyselyFactory = require('../KyselyFactory-Bdq1s1Go.cjs');
 require('../PostgresMigrator-BtAWdLss.cjs');
 require('../PostgresKyselyMigrator-Bs31emFd.cjs');
-require('../VitestTransactionIsolator-DcOz0LZF.cjs');
-require('../VitestKyselyTransactionIsolator-YWnSJiIH.cjs');
-const require_helpers = require('../helpers-H4hO5SZR.cjs');
-const require_kysely = require('../kysely-B-GOhABm.cjs');
-const require_helpers$1 = require('../helpers-Bnm3Jy9X.cjs');
+require('../VitestTransactionIsolator-CruLTRRi.cjs');
+require('../VitestKyselyTransactionIsolator-CIlpIO78.cjs');
+const require_helpers = require('../helpers-nEUtQ7eo.cjs');
+const require_kysely = require('../kysely-CBfCXxUn.cjs');
+const require_helpers$1 = require('../helpers-CNMBePuj.cjs');
 const vitest = require_chunk.__toESM(require("vitest"));
 
 //#region src/__tests__/integration.spec.ts