@geekmidas/testkit 0.0.14 → 0.0.16

package/dist/__tests__/PostgresKyselyMigrator.spec.mjs

@@ -1,396 +0,0 @@
-import { PostgresMigrator } from "../PostgresMigrator-DxPC_gGu.mjs";
-import { PostgresKyselyMigrator } from "../PostgresKyselyMigrator-Bdhl251C.mjs";
-import { createTestDatabase } from "../helpers-B4TXg3Wp.mjs";
-import { Kysely, PostgresDialect, sql } from "kysely";
-import { Client, Pool } from "pg";
-import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, it, vi } from "vitest";
-
-//#region src/__tests__/PostgresKyselyMigrator.spec.ts
-var TestMigrationProvider = class {
-	migrations = {};
-	shouldError = false;
-	addMigration(name, migration) {
-		this.migrations[name] = migration;
-	}
-	setError(shouldError) {
-		this.shouldError = shouldError;
-	}
-	async getMigrations() {
-		if (this.shouldError) throw new Error("Failed to load migrations");
-		return this.migrations;
-	}
-};
-describe("PostgresKyselyMigrator", () => {
-	let testDbName;
-	let cleanupDb;
-	let consoleSpy;
-	let consoleErrorSpy;
-	beforeAll(async () => {
-		testDbName = `test_kysely_migrator_${Date.now()}`;
-		cleanupDb = await createTestDatabase(testDbName);
-	});
-	beforeEach(() => {
-		consoleSpy = vi.spyOn(console, "log").mockImplementation(() => {});
-		consoleErrorSpy = vi.spyOn(console, "error").mockImplementation(() => {});
-	});
-	afterEach(() => {
-		consoleSpy.mockRestore();
-		consoleErrorSpy.mockRestore();
-	});
-	afterAll(async () => {
-		await cleanupDb();
-	});
-	describe("constructor", () => {
-		it("should create a PostgresKyselyMigrator instance", () => {
-			const db = new Kysely({ dialect: new PostgresDialect({ pool: new Pool({
-				host: "localhost",
-				port: 5432,
-				user: "geekmidas",
-				password: "geekmidas",
-				database: testDbName
-			}) }) });
-			const provider = new TestMigrationProvider();
-			const migrator = new PostgresKyselyMigrator({
-				uri: `postgresql://geekmidas:geekmidas@localhost:5432/${testDbName}`,
-				db,
-				provider
-			});
-			expect(migrator).toBeInstanceOf(PostgresKyselyMigrator);
-			expect(migrator).toBeInstanceOf(PostgresMigrator);
-		});
-	});
-	describe("migrate method", () => {
-		it("should apply migrations successfully", async () => {
-			const newDbName = `test_migrate_${Date.now()}`;
-			const uri = `postgresql://geekmidas:geekmidas@localhost:5432/${newDbName}`;
-			const db = new Kysely({ dialect: new PostgresDialect({ pool: new Pool({
-				host: "localhost",
-				port: 5432,
-				user: "geekmidas",
-				password: "geekmidas",
-				database: newDbName
-			}) }) });
-			const provider = new TestMigrationProvider();
-			provider.addMigration("001_create_users", {
-				up: async (db$1) => {
-					await db$1.schema.createTable("users").addColumn("id", "serial", (col) => col.primaryKey()).addColumn("name", "varchar", (col) => col.notNull()).addColumn("email", "varchar", (col) => col.notNull().unique()).addColumn("created_at", "timestamp", (col) => col.defaultTo(sql`now()`).notNull()).execute();
-				},
-				down: async (db$1) => {
-					await db$1.schema.dropTable("users").execute();
-				}
-			});
-			provider.addMigration("002_create_posts", {
-				up: async (db$1) => {
-					await db$1.schema.createTable("posts").addColumn("id", "serial", (col) => col.primaryKey()).addColumn("title", "varchar", (col) => col.notNull()).addColumn("content", "text", (col) => col.notNull()).addColumn("user_id", "integer", (col) => col.notNull().references("users.id").onDelete("cascade")).addColumn("created_at", "timestamp", (col) => col.defaultTo(sql`now()`).notNull()).execute();
-				},
-				down: async (db$1) => {
-					await db$1.schema.dropTable("posts").execute();
-				}
-			});
-			const migrator = new PostgresKyselyMigrator({
-				uri,
-				db,
-				provider
-			});
-			const cleanup = await migrator.start();
-			expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining("Applied 2 migrations successfully"));
-			const client = new Client({
-				host: "localhost",
-				port: 5432,
-				user: "geekmidas",
-				password: "geekmidas",
-				database: newDbName
-			});
-			try {
-				await client.connect();
-				const tablesResult = await client.query(`
-          SELECT table_name FROM information_schema.tables
-          WHERE table_schema = 'public' 
-          AND table_name IN ('users', 'posts')
-          ORDER BY table_name
-        `);
-				expect(tablesResult.rowCount).toBe(2);
-				expect(tablesResult.rows).toEqual([{ table_name: "posts" }, { table_name: "users" }]);
-			} finally {
-				await client.end();
-			}
-			await cleanup();
-		});
-		it("should handle migration errors", async () => {
-			const errorDbName = `test_migrate_error_${Date.now()}`;
-			const uri = `postgresql://geekmidas:geekmidas@localhost:5432/${errorDbName}`;
-			const db = new Kysely({ dialect: new PostgresDialect({ pool: new Pool({
-				host: "localhost",
-				port: 5432,
-				user: "geekmidas",
-				password: "geekmidas",
-				database: errorDbName
-			}) }) });
-			const provider = new TestMigrationProvider();
-			provider.addMigration("001_failing_migration", { up: async () => {
-				throw new Error("Migration failed intentionally");
-			} });
-			const migrator = new PostgresKyselyMigrator({
-				uri,
-				db,
-				provider
-			});
-			await expect(migrator.start()).rejects.toThrow("Migration failed intentionally");
-			expect(consoleErrorSpy).toHaveBeenCalledWith(expect.any(Error), "Failed to apply migrations");
-			await db.destroy();
-			const cleanupClient = new Client({
-				host: "localhost",
-				port: 5432,
-				user: "geekmidas",
-				password: "geekmidas",
-				database: "postgres"
-			});
-			try {
-				await cleanupClient.connect();
-				await cleanupClient.query(`
-          SELECT pg_terminate_backend(pg_stat_activity.pid)
-          FROM pg_stat_activity
-          WHERE pg_stat_activity.datname = '${errorDbName}'
-            AND pid <> pg_backend_pid()
-        `);
-				await cleanupClient.query(`DROP DATABASE IF EXISTS "${errorDbName}"`);
-			} finally {
-				await cleanupClient.end();
-			}
-		});
-		it("should destroy database connection after migrations", async () => {
-			const destroyDbName = `test_destroy_${Date.now()}`;
-			const uri = `postgresql://geekmidas:geekmidas@localhost:5432/${destroyDbName}`;
-			const db = new Kysely({ dialect: new PostgresDialect({ pool: new Pool({
-				host: "localhost",
-				port: 5432,
-				user: "geekmidas",
-				password: "geekmidas",
-				database: destroyDbName
-			}) }) });
-			const destroySpy = vi.spyOn(db, "destroy");
-			const provider = new TestMigrationProvider();
-			provider.addMigration("001_simple", { up: async (db$1) => {
-				await db$1.schema.createTable("test").addColumn("id", "serial", (col) => col.primaryKey()).execute();
-			} });
-			const migrator = new PostgresKyselyMigrator({
-				uri,
-				db,
-				provider
-			});
-			const cleanup = await migrator.start();
-			expect(destroySpy).toHaveBeenCalled();
-			await cleanup();
-		});
-	});
-	describe("integration with PostgresMigrator", () => {
-		it("should work with complete workflow", async () => {
-			const integrationDbName = `test_integration_${Date.now()}`;
-			const uri = `postgresql://geekmidas:geekmidas@localhost:5432/${integrationDbName}`;
-			const db = new Kysely({ dialect: new PostgresDialect({ pool: new Pool({
-				host: "localhost",
-				port: 5432,
-				user: "geekmidas",
-				password: "geekmidas",
-				database: integrationDbName
-			}) }) });
-			const provider = new TestMigrationProvider();
-			provider.addMigration("001_initial_schema", { up: async (db$1) => {
-				await db$1.schema.createTable("users").addColumn("id", "serial", (col) => col.primaryKey()).addColumn("name", "varchar", (col) => col.notNull()).addColumn("email", "varchar", (col) => col.notNull().unique()).addColumn("created_at", "timestamp", (col) => col.defaultTo(sql`now()`).notNull()).execute();
-				await db$1.schema.createTable("posts").addColumn("id", "serial", (col) => col.primaryKey()).addColumn("title", "varchar", (col) => col.notNull()).addColumn("content", "text", (col) => col.notNull()).addColumn("user_id", "integer", (col) => col.notNull().references("users.id").onDelete("cascade")).addColumn("created_at", "timestamp", (col) => col.defaultTo(sql`now()`).notNull()).execute();
-				await db$1.schema.createIndex("idx_posts_user_id").on("posts").column("user_id").execute();
-			} });
-			provider.addMigration("002_add_updated_at", { up: async (db$1) => {
-				await db$1.schema.alterTable("users").addColumn("updated_at", "timestamp", (col) => col.defaultTo(sql`now()`).notNull()).execute();
-				await db$1.schema.alterTable("posts").addColumn("updated_at", "timestamp", (col) => col.defaultTo(sql`now()`).notNull()).execute();
-			} });
-			const migrator = new PostgresKyselyMigrator({
-				uri,
-				db,
-				provider
-			});
-			const cleanup = await migrator.start();
-			expect(consoleSpy).toHaveBeenCalledWith(`Migrating database: ${integrationDbName}`);
-			expect(consoleSpy).toHaveBeenCalledWith("Applied 2 migrations successfully");
-			const verifyClient = new Client({
-				host: "localhost",
-				port: 5432,
-				user: "geekmidas",
-				password: "geekmidas",
-				database: integrationDbName
-			});
-			try {
-				await verifyClient.connect();
-				const columnsResult = await verifyClient.query(`
-          SELECT table_name, column_name 
-          FROM information_schema.columns
-          WHERE table_schema = 'public' 
-          AND table_name IN ('users', 'posts')
-          AND column_name = 'updated_at'
-          ORDER BY table_name
-        `);
-				expect(columnsResult.rowCount).toBe(2);
-				const indexResult = await verifyClient.query(`
-          SELECT indexname FROM pg_indexes
-          WHERE schemaname = 'public'
-          AND indexname = 'idx_posts_user_id'
-        `);
-				expect(indexResult.rowCount).toBe(1);
-			} finally {
-				await verifyClient.end();
-			}
-			await cleanup();
-		});
-		it("should handle empty migrations", async () => {
-			const emptyDbName = `test_empty_${Date.now()}`;
-			const uri = `postgresql://geekmidas:geekmidas@localhost:5432/${emptyDbName}`;
-			const db = new Kysely({ dialect: new PostgresDialect({ pool: new Pool({
-				host: "localhost",
-				port: 5432,
-				user: "geekmidas",
-				password: "geekmidas",
-				database: emptyDbName
-			}) }) });
-			const provider = new TestMigrationProvider();
-			const migrator = new PostgresKyselyMigrator({
-				uri,
-				db,
-				provider
-			});
-			const cleanup = await migrator.start();
-			expect(consoleSpy).toHaveBeenCalledWith("Applied 0 migrations successfully");
-			await cleanup();
-		});
-		it("should work with FileMigrationProvider pattern", async () => {
-			const fileProviderDbName = `test_file_provider_${Date.now()}`;
-			const uri = `postgresql://geekmidas:geekmidas@localhost:5432/${fileProviderDbName}`;
-			const db = new Kysely({ dialect: new PostgresDialect({ pool: new Pool({
-				host: "localhost",
-				port: 5432,
-				user: "geekmidas",
-				password: "geekmidas",
-				database: fileProviderDbName
-			}) }) });
-			const migrations = {
-				"2024_01_01_000001_create_users": {
-					up: async (db$1) => {
-						await db$1.schema.createTable("users").addColumn("id", "serial", (col) => col.primaryKey()).addColumn("username", "varchar", (col) => col.notNull().unique()).execute();
-					},
-					down: async (db$1) => {
-						await db$1.schema.dropTable("users").execute();
-					}
-				},
-				"2024_01_02_000001_create_sessions": {
-					up: async (db$1) => {
-						await db$1.schema.createTable("sessions").addColumn("id", "serial", (col) => col.primaryKey()).addColumn("user_id", "integer", (col) => col.notNull().references("users.id")).addColumn("token", "varchar", (col) => col.notNull()).execute();
-					},
-					down: async (db$1) => {
-						await db$1.schema.dropTable("sessions").execute();
-					}
-				}
-			};
-			const provider = { async getMigrations() {
-				return migrations;
-			} };
-			const migrator = new PostgresKyselyMigrator({
-				uri,
-				db,
-				provider
-			});
-			const cleanup = await migrator.start();
-			expect(consoleSpy).toHaveBeenCalledWith("Applied 2 migrations successfully");
-			const verifyClient = new Client({
-				host: "localhost",
-				port: 5432,
-				user: "geekmidas",
-				password: "geekmidas",
-				database: fileProviderDbName
-			});
-			try {
-				await verifyClient.connect();
-				const tablesResult = await verifyClient.query(`
-          SELECT table_name FROM information_schema.tables
-          WHERE table_schema = 'public' 
-          AND table_name IN ('users', 'sessions')
-          ORDER BY table_name
-        `);
-				expect(tablesResult.rowCount).toBe(2);
-			} finally {
-				await verifyClient.end();
-			}
-			await cleanup();
-		});
-	});
-	describe("error scenarios", () => {
-		it("should handle provider errors", async () => {
-			const providerErrorDbName = `test_provider_error_${Date.now()}`;
-			const uri = `postgresql://geekmidas:geekmidas@localhost:5432/${providerErrorDbName}`;
-			const db = new Kysely({ dialect: new PostgresDialect({ pool: new Pool({
-				host: "localhost",
-				port: 5432,
-				user: "geekmidas",
-				password: "geekmidas",
-				database: providerErrorDbName
-			}) }) });
-			const provider = new TestMigrationProvider();
-			provider.setError(true);
-			const migrator = new PostgresKyselyMigrator({
-				uri,
-				db,
-				provider
-			});
-			await expect(migrator.start()).rejects.toThrow("Failed to load migrations");
-			await db.destroy();
-			const cleanupClient = new Client({
-				host: "localhost",
-				port: 5432,
-				user: "geekmidas",
-				password: "geekmidas",
-				database: "postgres"
-			});
-			try {
-				await cleanupClient.connect();
-				await cleanupClient.query(`DROP DATABASE IF EXISTS "${providerErrorDbName}"`);
-			} finally {
-				await cleanupClient.end();
-			}
-		}, 1e4);
-		it("should handle invalid SQL in migrations", async () => {
-			const invalidSqlDbName = `test_invalid_sql_${Date.now()}`;
-			const uri = `postgresql://geekmidas:geekmidas@localhost:5432/${invalidSqlDbName}`;
-			const db = new Kysely({ dialect: new PostgresDialect({ pool: new Pool({
-				host: "localhost",
-				port: 5432,
-				user: "geekmidas",
-				password: "geekmidas",
-				database: invalidSqlDbName
-			}) }) });
-			const provider = new TestMigrationProvider();
-			provider.addMigration("001_invalid_sql", { up: async (db$1) => {
-				await db$1.schema.createTable("posts").addColumn("id", "serial", (col) => col.primaryKey()).addColumn("user_id", "integer", (col) => col.notNull().references("non_existent_table.id")).execute();
-			} });
-			const migrator = new PostgresKyselyMigrator({
-				uri,
-				db,
-				provider
-			});
-			await expect(migrator.start()).rejects.toThrow();
-			await db.destroy();
-			const cleanupClient = new Client({
-				host: "localhost",
-				port: 5432,
-				user: "geekmidas",
-				password: "geekmidas",
-				database: "postgres"
-			});
-			try {
-				await cleanupClient.connect();
-				await cleanupClient.query(`DROP DATABASE IF EXISTS "${invalidSqlDbName}"`);
-			} finally {
-				await cleanupClient.end();
-			}
-		}, 1e4);
-	});
-});
-
-//#endregion

package/dist/__tests__/PostgresMigrator.spec.cjs

@@ -1,256 +0,0 @@
-const require_chunk = require('../chunk-CUT6urMc.cjs');
-const require_PostgresMigrator = require('../PostgresMigrator-DFcNdCvD.cjs');
-const require_helpers = require('../helpers-Bf0nXhbu.cjs');
-const pg = require_chunk.__toESM(require("pg"));
-const vitest = require_chunk.__toESM(require("vitest"));
-
-//#region src/__tests__/PostgresMigrator.spec.ts
-var TestPostgresMigrator = class extends require_PostgresMigrator.PostgresMigrator {
-	migrateCalled = false;
-	migrateError;
-	customMigrations = [];
-	async migrate() {
-		this.migrateCalled = true;
-		if (this.migrateError) throw this.migrateError;
-		for (const migration of this.customMigrations) await migration();
-	}
-	addMigration(migration) {
-		this.customMigrations.push(migration);
-	}
-};
-(0, vitest.describe)("PostgresMigrator", () => {
-	let testDbName;
-	let cleanupDb;
-	let consoleSpy;
-	(0, vitest.beforeAll)(async () => {
-		testDbName = `test_postgres_migrator_${Date.now()}`;
-		cleanupDb = await require_helpers.createTestDatabase(testDbName);
-	});
-	(0, vitest.beforeEach)(() => {
-		consoleSpy = vitest.vi.spyOn(console, "log").mockImplementation(() => {});
-	});
-	(0, vitest.afterEach)(() => {
-		consoleSpy.mockRestore();
-	});
-	(0, vitest.afterAll)(async () => {
-		await cleanupDb();
-	});
-	(0, vitest.describe)("constructor", () => {
-		(0, vitest.it)("should create a PostgresMigrator instance", () => {
-			const migrator = new TestPostgresMigrator(`postgresql://geekmidas:geekmidas@localhost:5432/${testDbName}`);
-			(0, vitest.expect)(migrator).toBeInstanceOf(require_PostgresMigrator.PostgresMigrator);
-		});
-	});
-	(0, vitest.describe)("start method", () => {
-		(0, vitest.it)("should create database, migrate, and return cleanup function", async () => {
-			const newDbName = `test_start_${Date.now()}`;
-			const uri = `postgresql://geekmidas:geekmidas@localhost:5432/${newDbName}`;
-			const migrator = new TestPostgresMigrator(uri);
-			let migrationRan = false;
-			migrator.addMigration(async () => {
-				migrationRan = true;
-			});
-			const cleanup = await migrator.start();
-			(0, vitest.expect)(migrator.migrateCalled).toBe(true);
-			(0, vitest.expect)(migrationRan).toBe(true);
-			(0, vitest.expect)(consoleSpy).toHaveBeenCalledWith(`Migrating database: ${newDbName}`);
-			(0, vitest.expect)(typeof cleanup).toBe("function");
-			await cleanup();
-		});
-		(0, vitest.it)("should handle existing database", async () => {
-			const uri = `postgresql://geekmidas:geekmidas@localhost:5432/${testDbName}`;
-			const migrator = new TestPostgresMigrator(uri);
-			let migrationRan = false;
-			migrator.addMigration(async () => {
-				migrationRan = true;
-			});
-			const cleanup = await migrator.start();
-			(0, vitest.expect)(migrator.migrateCalled).toBe(true);
-			(0, vitest.expect)(migrationRan).toBe(true);
-			(0, vitest.expect)(typeof cleanup).toBe("function");
-		});
-		(0, vitest.it)("should handle URI with query parameters", async () => {
-			const queryDbName = `test_query_params_${Date.now()}`;
-			const uri = `postgresql://geekmidas:geekmidas@localhost:5432/${queryDbName}?ssl=false&timeout=30`;
-			const migrator = new TestPostgresMigrator(uri);
-			const cleanup = await migrator.start();
-			(0, vitest.expect)(migrator.migrateCalled).toBe(true);
-			(0, vitest.expect)(typeof cleanup).toBe("function");
-			await cleanup();
-		});
-		(0, vitest.it)("should clean up connections even if migration fails", async () => {
-			const failDbName = `test_fail_${Date.now()}`;
-			const uri = `postgresql://geekmidas:geekmidas@localhost:5432/${failDbName}`;
-			const migrator = new TestPostgresMigrator(uri);
-			migrator.migrateError = new Error("Migration failed");
-			await (0, vitest.expect)(migrator.start()).rejects.toThrow("Migration failed");
-			(0, vitest.expect)(migrator.migrateCalled).toBe(true);
-			const cleanupClient = new pg.Client({
-				host: "localhost",
-				port: 5432,
-				user: "geekmidas",
-				password: "geekmidas",
-				database: "postgres"
-			});
-			try {
-				await cleanupClient.connect();
-				await cleanupClient.query(`DROP DATABASE IF EXISTS "${failDbName}"`);
-			} finally {
-				await cleanupClient.end();
-			}
-		});
-		(0, vitest.it)("should return cleanup function that drops database", async () => {
-			const cleanupDbName = `test_cleanup_${Date.now()}`;
-			const uri = `postgresql://geekmidas:geekmidas@localhost:5432/${cleanupDbName}`;
-			const migrator = new TestPostgresMigrator(uri);
-			const cleanup = await migrator.start();
-			(0, vitest.expect)(migrator.migrateCalled).toBe(true);
-			(0, vitest.expect)(typeof cleanup).toBe("function");
-			const checkClient = new pg.Client({
-				host: "localhost",
-				port: 5432,
-				user: "geekmidas",
-				password: "geekmidas",
-				database: "postgres"
-			});
-			await checkClient.connect();
-			const beforeResult = await checkClient.query(`SELECT * FROM pg_catalog.pg_database WHERE datname = $1`, [cleanupDbName]);
-			(0, vitest.expect)(beforeResult.rowCount).toBe(1);
-			await checkClient.end();
-			await cleanup();
-			const checkClient2 = new pg.Client({
-				host: "localhost",
-				port: 5432,
-				user: "geekmidas",
-				password: "geekmidas",
-				database: "postgres"
-			});
-			await checkClient2.connect();
-			const afterResult = await checkClient2.query(`SELECT * FROM pg_catalog.pg_database WHERE datname = $1`, [cleanupDbName]);
-			(0, vitest.expect)(afterResult.rowCount).toBe(0);
-			await checkClient2.end();
-		});
-	});
-	(0, vitest.describe)("database creation", () => {
-		(0, vitest.it)("should handle connection errors gracefully", async () => {
-			const badDbName = `test_bad_connection_${Date.now()}`;
-			const uri = `postgresql://invalid_user:invalid_pass@localhost:5432/${badDbName}`;
-			const migrator = new TestPostgresMigrator(uri);
-			await (0, vitest.expect)(migrator.start()).rejects.toThrow();
-		});
-		(0, vitest.it)("should handle invalid database names", async () => {
-			const invalidDbName = "test-invalid-db-name!";
-			const uri = `postgresql://geekmidas:geekmidas@localhost:5432/${invalidDbName}`;
-			const migrator = new TestPostgresMigrator(uri);
-			await (0, vitest.expect)(migrator.start).rejects.toThrow();
-		});
-	});
-	(0, vitest.describe)("URI parsing", () => {
-		(0, vitest.it)("should parse different URI formats correctly", async () => {
-			const testDbName$1 = `test_uri_parsing_${Date.now()}`;
-			const uri = `postgresql://geekmidas:geekmidas@localhost:5432/${testDbName$1}`;
-			const migrator = new TestPostgresMigrator(uri);
-			const cleanup = await migrator.start();
-			(0, vitest.expect)(migrator.migrateCalled).toBe(true);
-			(0, vitest.expect)(typeof cleanup).toBe("function");
-			await cleanup();
-		});
-	});
-	(0, vitest.describe)("error handling", () => {
-		(0, vitest.it)("should propagate migration errors", async () => {
-			const errorDbName = `test_migration_error_${Date.now()}`;
-			const uri = `postgresql://geekmidas:geekmidas@localhost:5432/${errorDbName}`;
-			const migrator = new TestPostgresMigrator(uri);
-			const migrationError = new Error("Custom migration error");
-			migrator.migrateError = migrationError;
-			await (0, vitest.expect)(migrator.start()).rejects.toThrow("Custom migration error");
-			const cleanupClient = new pg.Client({
-				host: "localhost",
-				port: 5432,
-				user: "geekmidas",
-				password: "geekmidas",
-				database: "postgres"
-			});
-			try {
-				await cleanupClient.connect();
-				await cleanupClient.query(`DROP DATABASE IF EXISTS "${errorDbName}"`);
-			} finally {
-				await cleanupClient.end();
-			}
-		});
-		(0, vitest.it)("should handle cleanup errors gracefully", async () => {
-			const cleanupErrorDbName = `test_cleanup_error_${Date.now()}`;
-			const uri = `postgresql://geekmidas:geekmidas@localhost:5432/${cleanupErrorDbName}`;
-			const migrator = new TestPostgresMigrator(uri);
-			const cleanup = await migrator.start();
-			const adminClient = new pg.Client({
-				host: "localhost",
-				port: 5432,
-				user: "geekmidas",
-				password: "geekmidas",
-				database: "postgres"
-			});
-			await adminClient.connect();
-			await adminClient.query(`DROP DATABASE IF EXISTS "${cleanupErrorDbName}"`);
-			await adminClient.end();
-			await (0, vitest.expect)(cleanup()).rejects.toThrow();
-		});
-	});
-	(0, vitest.describe)("abstract method", () => {
-		(0, vitest.it)("should require concrete implementation of migrate method", () => {
-			const migrator = new TestPostgresMigrator(`postgresql://geekmidas:geekmidas@localhost:5432/${testDbName}`);
-			(0, vitest.expect)(typeof migrator.migrate).toBe("function");
-		});
-	});
-	(0, vitest.describe)("integration scenarios", () => {
-		(0, vitest.it)("should handle complete workflow", async () => {
-			const integrationDbName = `test_integration_${Date.now()}`;
-			const uri = `postgresql://geekmidas:geekmidas@localhost:5432/${integrationDbName}`;
-			const migrator = new TestPostgresMigrator(uri);
-			migrator.addMigration(async () => {
-				const client = new pg.Client({
-					host: "localhost",
-					port: 5432,
-					user: "geekmidas",
-					password: "geekmidas",
-					database: integrationDbName
-				});
-				await client.connect();
-				await client.query(`
-          CREATE TABLE IF NOT EXISTS test_table (
-            id SERIAL PRIMARY KEY,
-            name VARCHAR(255) NOT NULL
-          )
-        `);
-				await client.end();
-			});
-			const cleanup = await migrator.start();
-			(0, vitest.expect)(migrator.migrateCalled).toBe(true);
-			(0, vitest.expect)(consoleSpy).toHaveBeenCalledWith(`Migrating database: ${integrationDbName}`);
-			const verifyClient = new pg.Client({
-				host: "localhost",
-				port: 5432,
-				user: "geekmidas",
-				password: "geekmidas",
-				database: integrationDbName
-			});
-			await verifyClient.connect();
-			const tableResult = await verifyClient.query(`
-        SELECT table_name FROM information_schema.tables 
-        WHERE table_schema = 'public' AND table_name = 'test_table'
-      `);
-			(0, vitest.expect)(tableResult.rowCount).toBe(1);
-			await verifyClient.end();
-			await cleanup();
-		});
-		(0, vitest.it)("should handle database that already exists and cleanup", async () => {
-			const uri = `postgresql://geekmidas:geekmidas@localhost:5432/${testDbName}`;
-			const migrator = new TestPostgresMigrator(uri);
-			const cleanup = await migrator.start();
-			(0, vitest.expect)(migrator.migrateCalled).toBe(true);
-			(0, vitest.expect)(typeof cleanup).toBe("function");
-		});
-	});
-});
-
-//#endregion

package/dist/__tests__/PostgresMigrator.spec.d.cts

@@ -1 +0,0 @@
-export { };

package/dist/__tests__/PostgresMigrator.spec.d.mts

@@ -1 +0,0 @@
-export { };