@geekmidas/testkit 1.0.3 → 1.0.5

package/dist/os/index.d.mts

@@ -1,2 +1,2 @@
-import { itWithDir } from "../directory-YzQUGC5g.mjs";
+import { itWithDir } from "../directory-CYXmolu1.mjs";
 export { itWithDir };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@geekmidas/testkit",
-  "version": "1.0.3",
+  "version": "1.0.5",
   "private": false,
   "type": "module",
   "exports": {
@@ -80,8 +80,8 @@
     "vitest": "~3.2.4",
     "@types/aws-lambda": ">=8.10.92",
     "better-auth": ">=1.3.34",
-    "@geekmidas/logger": "^1.0.0",
-    "@geekmidas/envkit": "^1.0.3"
+    "@geekmidas/envkit": "^1.0.3",
+    "@geekmidas/logger": "^1.0.0"
   },
   "peerDependenciesMeta": {
     "@geekmidas/envkit": {

package/src/PostgresKyselyMigrator.ts

@@ -40,6 +40,18 @@ const logger = console;
  * const cleanup = await migrator.start();
  * // Run tests...
  * await cleanup();
+ *
+ * // With afterCreate hook to create per-app users
+ * import { runInitScript } from '@geekmidas/testkit/postgres';
+ *
+ * const migrator = new PostgresKyselyMigrator({
+ *   uri: 'postgresql://localhost:5432/test_db',
+ *   db,
+ *   provider,
+ *   afterCreate: async (uri) => {
+ *     await runInitScript('docker/postgres/init.sh', uri, env);
+ *   },
+ * });
  * ```
  */
 export class PostgresKyselyMigrator extends PostgresMigrator {
@@ -50,15 +62,17 @@ export class PostgresKyselyMigrator extends PostgresMigrator {
 	 * @param options.uri - PostgreSQL connection URI
 	 * @param options.db - Kysely database instance
 	 * @param options.provider - Migration provider for locating migration files
+	 * @param options.afterCreate - Optional hook called after database creation but before migrations
 	 */
 	constructor(
 		private options: {
 			uri: string;
 			db: Kysely<any>;
 			provider: MigrationProvider;
+			afterCreate?: (uri: string) => Promise<void>;
 		},
 	) {
-		super(options.uri);
+		super(options.uri, options.afterCreate);
 	}
 
 	/**

package/src/PostgresMigrator.ts

@@ -57,6 +57,17 @@ const logger = console;
  * const migrator = new MyMigrator('postgresql://localhost:5432/test_db');
  * const cleanup = await migrator.start();
  *
+ * // With afterCreate hook (e.g. run init script to create per-app users)
+ * import { runInitScript } from '@geekmidas/testkit/postgres';
+ *
+ * const migrator = new MyMigrator(
+ *   'postgresql://localhost:5432/test_db',
+ *   async (uri) => {
+ *     await runInitScript('docker/postgres/init.sh', uri, env);
+ *   },
+ * );
+ * const cleanup = await migrator.start();
+ *
  * // Run tests...
  *
  * // Clean up
@@ -68,8 +79,12 @@ export abstract class PostgresMigrator {
 	 * Creates a new PostgresMigrator instance.
 	 *
 	 * @param uri - PostgreSQL connection URI
+	 * @param afterCreate - Optional hook called after database creation but before migrations
 	 */
-	constructor(private uri: string) {}
+	constructor(
+		private uri: string,
+		private afterCreate?: (uri: string) => Promise<void>,
+	) {}
 
 	/**
 	 * Abstract method to be implemented by subclasses.
@@ -161,7 +176,9 @@ export abstract class PostgresMigrator {
 		const { database, db } = await setupClient(this.uri);
 		try {
 			await PostgresMigrator.create(this.uri);
-			// Implement migration logic here
+			if (this.afterCreate) {
+				await this.afterCreate(this.uri);
+			}
 			await this.migrate();
 			logger.log(`Migrating database: ${database}`);
 			// Example: await db.query('CREATE TABLE example (id SERIAL PRIMARY KEY)');

package/src/__tests__/PostgresKyselyMigrator.spec.ts

@@ -577,6 +577,110 @@ describe('PostgresKyselyMigrator', () => {
 		});
 	});
 
+	describe('afterCreate hook', () => {
+		it('should call afterCreate before migrations run', async () => {
+			const hookDbName = `test_kysely_hook_${Date.now()}`;
+			const uri = `postgresql://geekmidas:geekmidas@localhost:5432/${hookDbName}`;
+			const callOrder: string[] = [];
+
+			const db = new Kysely<TestSchema>({
+				dialect: new PostgresDialect({
+					pool: new Pool({
+						host: 'localhost',
+						port: 5432,
+						user: 'geekmidas',
+						password: 'geekmidas',
+						database: hookDbName,
+					}),
+				}),
+			});
+
+			const provider = new TestMigrationProvider();
+			provider.addMigration('001_create_table', {
+				up: async (db) => {
+					callOrder.push('migrate');
+					await db.schema
+						.createTable('items')
+						.addColumn('id', 'serial', (col) => col.primaryKey())
+						.execute();
+				},
+			});
+
+			const migrator = new PostgresKyselyMigrator({
+				uri,
+				db,
+				provider,
+				afterCreate: async (receivedUri) => {
+					callOrder.push('afterCreate');
+					expect(receivedUri).toBe(uri);
+				},
+			});
+
+			const cleanup = await migrator.start();
+
+			expect(callOrder).toEqual(['afterCreate', 'migrate']);
+
+			await cleanup();
+		});
+
+		it('should allow creating users and schemas before migrations', async () => {
+			const schemaDbName = `test_kysely_schema_hook_${Date.now()}`;
+			const uri = `postgresql://geekmidas:geekmidas@localhost:5432/${schemaDbName}`;
+
+			const db = new Kysely<TestSchema>({
+				dialect: new PostgresDialect({
+					pool: new Pool({
+						host: 'localhost',
+						port: 5432,
+						user: 'geekmidas',
+						password: 'geekmidas',
+						database: schemaDbName,
+					}),
+				}),
+			});
+
+			const provider = new TestMigrationProvider();
+			provider.addMigration('001_use_schema', {
+				up: async (db) => {
+					// Verify schema exists (created by afterCreate)
+					const result =
+						await sql`SELECT schema_name FROM information_schema.schemata WHERE schema_name = 'app'`.execute(
+							db,
+						);
+					if (result.rows.length === 0) {
+						throw new Error('Expected app schema to exist');
+					}
+					await db.schema
+						.createTable('items')
+						.addColumn('id', 'serial', (col) => col.primaryKey())
+						.execute();
+				},
+			});
+
+			const migrator = new PostgresKyselyMigrator({
+				uri,
+				db,
+				provider,
+				afterCreate: async () => {
+					const client = new Client({
+						host: 'localhost',
+						port: 5432,
+						user: 'geekmidas',
+						password: 'geekmidas',
+						database: schemaDbName,
+					});
+					await client.connect();
+					await client.query('CREATE SCHEMA IF NOT EXISTS app');
+					await client.end();
+				},
+			});
+
+			const cleanup = await migrator.start();
+
+			await cleanup();
+		});
+	});
+
 	describe('error scenarios', () => {
 		it('should handle provider errors', async () => {
 			const providerErrorDbName = `test_provider_error_${Date.now()}`;

package/src/__tests__/PostgresMigrator.spec.ts

@@ -18,6 +18,10 @@ class TestPostgresMigrator extends PostgresMigrator {
 	public migrateError?: Error;
 	public customMigrations: Array<() => Promise<void>> = [];
 
+	constructor(uri: string, afterCreate?: (uri: string) => Promise<void>) {
+		super(uri, afterCreate);
+	}
+
 	async migrate(): Promise<void> {
 		this.migrateCalled = true;
 		if (this.migrateError) {
@@ -285,6 +289,111 @@ describe('PostgresMigrator', () => {
 		});
 	});
 
+	describe('afterCreate hook', () => {
+		it('should call afterCreate after database creation and before migrate', async () => {
+			const hookDbName = `test_after_create_${Date.now()}`;
+			const uri = `postgresql://geekmidas:geekmidas@localhost:5432/${hookDbName}`;
+			const callOrder: string[] = [];
+
+			const migrator = new TestPostgresMigrator(uri, async (receivedUri) => {
+				callOrder.push('afterCreate');
+				expect(receivedUri).toBe(uri);
+			});
+
+			migrator.addMigration(async () => {
+				callOrder.push('migrate');
+			});
+
+			const cleanup = await migrator.start();
+
+			expect(callOrder).toEqual(['afterCreate', 'migrate']);
+
+			await cleanup();
+		});
+
+		it('should skip afterCreate when not provided', async () => {
+			const noHookDbName = `test_no_hook_${Date.now()}`;
+			const uri = `postgresql://geekmidas:geekmidas@localhost:5432/${noHookDbName}`;
+			const migrator = new TestPostgresMigrator(uri);
+
+			const cleanup = await migrator.start();
+
+			expect(migrator.migrateCalled).toBe(true);
+
+			await cleanup();
+		});
+
+		it('should propagate afterCreate errors and not run migrate', async () => {
+			const errorHookDbName = `test_hook_error_${Date.now()}`;
+			const uri = `postgresql://geekmidas:geekmidas@localhost:5432/${errorHookDbName}`;
+
+			const migrator = new TestPostgresMigrator(uri, async () => {
+				throw new Error('afterCreate failed');
+			});
+
+			await expect(migrator.start()).rejects.toThrow('afterCreate failed');
+			expect(migrator.migrateCalled).toBe(false);
+
+			// Cleanup the created database
+			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 "${errorHookDbName}"`,
+				);
+			} finally {
+				await cleanupClient.end();
+			}
+		});
+
+		it('should allow afterCreate to set up database objects before migrations', async () => {
+			const setupDbName = `test_hook_setup_${Date.now()}`;
+			const uri = `postgresql://geekmidas:geekmidas@localhost:5432/${setupDbName}`;
+
+			const migrator = new TestPostgresMigrator(uri, async () => {
+				const client = new Client({
+					host: 'localhost',
+					port: 5432,
+					user: 'geekmidas',
+					password: 'geekmidas',
+					database: setupDbName,
+				});
+				await client.connect();
+				await client.query(
+					"CREATE SCHEMA IF NOT EXISTS app; COMMENT ON SCHEMA app IS 'Created by afterCreate hook';",
+				);
+				await client.end();
+			});
+
+			migrator.addMigration(async () => {
+				// Verify schema exists during migration
+				const client = new Client({
+					host: 'localhost',
+					port: 5432,
+					user: 'geekmidas',
+					password: 'geekmidas',
+					database: setupDbName,
+				});
+				await client.connect();
+				const result = await client.query(
+					"SELECT schema_name FROM information_schema.schemata WHERE schema_name = 'app'",
+				);
+				expect(result.rowCount).toBe(1);
+				await client.end();
+			});
+
+			const cleanup = await migrator.start();
+
+			await cleanup();
+		});
+	});
+
 	describe('abstract method', () => {
 		it('should require concrete implementation of migrate method', () => {
 			// TypeScript ensures abstract methods are implemented

package/src/__tests__/initScript.spec.ts

@@ -92,6 +92,30 @@ EOSQL`;
 		expect(blocks[0]).toContain("CREATE USER api WITH PASSWORD ''");
 	});
 
+	it('should unescape bash-escaped dollar signs for PL/pgSQL blocks', () => {
+		const script = `psql <<-EOSQL
+    DO \\$\\$
+    BEGIN
+        IF NOT EXISTS (SELECT FROM pg_roles WHERE rolname = 'api') THEN
+            CREATE USER api WITH PASSWORD '$API_DB_PASSWORD';
+        ELSE
+            ALTER USER api WITH PASSWORD '$API_DB_PASSWORD';
+        END IF;
+    END
+    \\$\\$;
+EOSQL`;
+
+		const blocks = parseInitScript(script, {
+			API_DB_PASSWORD: 'secret',
+		});
+
+		expect(blocks).toHaveLength(1);
+		expect(blocks[0]).toContain('DO $$');
+		expect(blocks[0]).toContain('END\n    $$;');
+		expect(blocks[0]).toContain("CREATE USER api WITH PASSWORD 'secret'");
+		expect(blocks[0]).not.toContain('\\$');
+	});
+
 	it('should return empty array for script with no heredocs', () => {
 		const script = `#!/bin/bash
 echo "Hello world"

package/src/initScript.ts

@@ -54,6 +54,9 @@ function substituteEnvVars(sql: string, env: Record<string, string>): string {
 	let result = sql.replace(/\$\{(\w+)\}/g, (_, name) => env[name] ?? '');
 	// Replace $VAR_NAME syntax (word boundary after)
 	result = result.replace(/\$(\w+)/g, (_, name) => env[name] ?? '');
+	// Unescape bash-escaped dollar signs (\$ → $) AFTER variable substitution
+	// This handles PL/pgSQL dollar-quoting like DO \$\$ ... END \$\$;
+	result = result.replace(/\\\$/g, '$');
 	return result;
 }
 

package/dist/PostgresKyselyMigrator-B4pScubb.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"PostgresKyselyMigrator-B4pScubb.mjs","names":["options: {\n\t\t\turi: string;\n\t\t\tdb: Kysely<any>;\n\t\t\tprovider: MigrationProvider;\n\t\t}"],"sources":["../src/PostgresKyselyMigrator.ts"],"sourcesContent":["import { type Kysely, type MigrationProvider, Migrator } from 'kysely';\nimport { PostgresMigrator } from './PostgresMigrator';\n\n/**\n * Default logger instance for migration operations.\n */\nconst logger = console;\n\n/**\n * PostgreSQL migrator implementation for Kysely ORM.\n * Extends PostgresMigrator to provide Kysely-specific migration functionality.\n * Automatically creates test databases and applies migrations for testing environments.\n *\n * @example\n * ```typescript\n * import { FileMigrationProvider } from 'kysely';\n * import { PostgresKyselyMigrator } from '@geekmidas/testkit';\n *\n * // Create migration provider\n * const provider = new FileMigrationProvider({\n *   fs: require('fs'),\n *   path: require('path'),\n *   migrationFolder: path.join(__dirname, 'migrations')\n * });\n *\n * // Create Kysely instance\n * const db = new Kysely<Database>({\n *   dialect: new PostgresDialect({\n *     pool: new Pool({ connectionString: uri })\n *   })\n * });\n *\n * // Create and use migrator\n * const migrator = new PostgresKyselyMigrator({\n *   uri: 'postgresql://localhost:5432/test_db',\n *   db,\n *   provider\n * });\n *\n * const cleanup = await migrator.start();\n * // Run tests...\n * await cleanup();\n * ```\n */\nexport class PostgresKyselyMigrator extends PostgresMigrator {\n\t/**\n\t * Creates a new PostgresKyselyMigrator instance.\n\t *\n\t * @param options - Configuration options\n\t * @param options.uri - PostgreSQL connection URI\n\t * @param options.db - Kysely database instance\n\t * @param options.provider - Migration provider for locating migration files\n\t */\n\tconstructor(\n\t\tprivate options: {\n\t\t\turi: string;\n\t\t\tdb: Kysely<any>;\n\t\t\tprovider: MigrationProvider;\n\t\t},\n\t) {\n\t\tsuper(options.uri);\n\t}\n\n\t/**\n\t * Executes Kysely migrations to the latest version.\n\t * Implements the abstract migrate() method from PostgresMigrator.\n\t *\n\t * @throws Error if migrations fail to apply\n\t * @returns Promise that resolves when all migrations are applied\n\t */\n\tasync migrate(): Promise<void> {\n\t\tconst migrator = new Migrator({\n\t\t\tdb: this.options.db,\n\t\t\tprovider: this.options.provider,\n\t\t});\n\t\tconst migrations = await migrator.migrateToLatest();\n\n\t\tif (migrations.error) {\n\t\t\tlogger.error(migrations.error, `Failed to apply migrations`);\n\t\t\tthrow migrations.error;\n\t\t}\n\n\t\tawait this.options.db.destroy();\n\n\t\tlogger.log(`Applied ${migrations.results?.length} migrations successfully`);\n\t}\n}\n"],"mappings":";;;;;;;AAMA,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAsCf,IAAa,yBAAb,cAA4C,iBAAiB;;;;;;;;;CAS5D,YACSA,SAKP;AACD,QAAM,QAAQ,IAAI;EANV;CAOR;;;;;;;;CASD,MAAM,UAAyB;EAC9B,MAAM,WAAW,IAAI,SAAS;GAC7B,IAAI,KAAK,QAAQ;GACjB,UAAU,KAAK,QAAQ;EACvB;EACD,MAAM,aAAa,MAAM,SAAS,iBAAiB;AAEnD,MAAI,WAAW,OAAO;AACrB,UAAO,MAAM,WAAW,QAAQ,4BAA4B;AAC5D,SAAM,WAAW;EACjB;AAED,QAAM,KAAK,QAAQ,GAAG,SAAS;AAE/B,SAAO,KAAK,UAAU,WAAW,SAAS,OAAO,0BAA0B;CAC3E;AACD"}

package/dist/PostgresKyselyMigrator-C7ljZYvq.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"PostgresKyselyMigrator-C7ljZYvq.cjs","names":["PostgresMigrator","options: {\n\t\t\turi: string;\n\t\t\tdb: Kysely<any>;\n\t\t\tprovider: MigrationProvider;\n\t\t}","Migrator"],"sources":["../src/PostgresKyselyMigrator.ts"],"sourcesContent":["import { type Kysely, type MigrationProvider, Migrator } from 'kysely';\nimport { PostgresMigrator } from './PostgresMigrator';\n\n/**\n * Default logger instance for migration operations.\n */\nconst logger = console;\n\n/**\n * PostgreSQL migrator implementation for Kysely ORM.\n * Extends PostgresMigrator to provide Kysely-specific migration functionality.\n * Automatically creates test databases and applies migrations for testing environments.\n *\n * @example\n * ```typescript\n * import { FileMigrationProvider } from 'kysely';\n * import { PostgresKyselyMigrator } from '@geekmidas/testkit';\n *\n * // Create migration provider\n * const provider = new FileMigrationProvider({\n *   fs: require('fs'),\n *   path: require('path'),\n *   migrationFolder: path.join(__dirname, 'migrations')\n * });\n *\n * // Create Kysely instance\n * const db = new Kysely<Database>({\n *   dialect: new PostgresDialect({\n *     pool: new Pool({ connectionString: uri })\n *   })\n * });\n *\n * // Create and use migrator\n * const migrator = new PostgresKyselyMigrator({\n *   uri: 'postgresql://localhost:5432/test_db',\n *   db,\n *   provider\n * });\n *\n * const cleanup = await migrator.start();\n * // Run tests...\n * await cleanup();\n * ```\n */\nexport class PostgresKyselyMigrator extends PostgresMigrator {\n\t/**\n\t * Creates a new PostgresKyselyMigrator instance.\n\t *\n\t * @param options - Configuration options\n\t * @param options.uri - PostgreSQL connection URI\n\t * @param options.db - Kysely database instance\n\t * @param options.provider - Migration provider for locating migration files\n\t */\n\tconstructor(\n\t\tprivate options: {\n\t\t\turi: string;\n\t\t\tdb: Kysely<any>;\n\t\t\tprovider: MigrationProvider;\n\t\t},\n\t) {\n\t\tsuper(options.uri);\n\t}\n\n\t/**\n\t * Executes Kysely migrations to the latest version.\n\t * Implements the abstract migrate() method from PostgresMigrator.\n\t *\n\t * @throws Error if migrations fail to apply\n\t * @returns Promise that resolves when all migrations are applied\n\t */\n\tasync migrate(): Promise<void> {\n\t\tconst migrator = new Migrator({\n\t\t\tdb: this.options.db,\n\t\t\tprovider: this.options.provider,\n\t\t});\n\t\tconst migrations = await migrator.migrateToLatest();\n\n\t\tif (migrations.error) {\n\t\t\tlogger.error(migrations.error, `Failed to apply migrations`);\n\t\t\tthrow migrations.error;\n\t\t}\n\n\t\tawait this.options.db.destroy();\n\n\t\tlogger.log(`Applied ${migrations.results?.length} migrations successfully`);\n\t}\n}\n"],"mappings":";;;;;;;;AAMA,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAsCf,IAAa,yBAAb,cAA4CA,0CAAiB;;;;;;;;;CAS5D,YACSC,SAKP;AACD,QAAM,QAAQ,IAAI;EANV;CAOR;;;;;;;;CASD,MAAM,UAAyB;EAC9B,MAAM,WAAW,IAAIC,gBAAS;GAC7B,IAAI,KAAK,QAAQ;GACjB,UAAU,KAAK,QAAQ;EACvB;EACD,MAAM,aAAa,MAAM,SAAS,iBAAiB;AAEnD,MAAI,WAAW,OAAO;AACrB,UAAO,MAAM,WAAW,QAAQ,4BAA4B;AAC5D,SAAM,WAAW;EACjB;AAED,QAAM,KAAK,QAAQ,GAAG,SAAS;AAE/B,SAAO,KAAK,UAAU,WAAW,SAAS,OAAO,0BAA0B;CAC3E;AACD"}

package/dist/PostgresKyselyMigrator-CBltSOq5.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"PostgresKyselyMigrator-CBltSOq5.d.cts","names":[],"sources":["../src/PostgresKyselyMigrator.ts"],"sourcesContent":[],"mappings":";;;;;;;AA4CA;;;;;;AAA4D;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAA/C,sBAAA,SAA+B,gBAAA;;;;;;;;;;;;QAYrC;cACM;;;;;;;;;aAaK"}

package/dist/PostgresKyselyMigrator-DrVWncqd.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"PostgresKyselyMigrator-DrVWncqd.d.mts","names":[],"sources":["../src/PostgresKyselyMigrator.ts"],"sourcesContent":[],"mappings":";;;;;;;AA4CA;;;;;;AAA4D;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAA/C,sBAAA,SAA+B,gBAAA;;;;;;;;;;;;QAYrC;cACM;;;;;;;;;aAaK"}

package/dist/PostgresMigrator-Bres0U6E.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"PostgresMigrator-Bres0U6E.d.cts","names":[],"sources":["../src/PostgresMigrator.ts"],"sourcesContent":[],"mappings":";;AAiEA;;;;;AA8FY;;;;;;;;;;;;;;;;;;uBA9FU,gBAAA;;;;;;;;;;;;;;sBAcD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WAgFT,cAAA"}

package/dist/PostgresMigrator-CHiBYEg_.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"PostgresMigrator-CHiBYEg_.cjs","names":["uri: string","error: any"],"sources":["../src/PostgresMigrator.ts"],"sourcesContent":["import pg from 'pg';\n\nconst { Client } = pg;\n\n/**\n * Creates a PostgreSQL client connected to the 'postgres' database.\n * Extracts connection details from the provided URI.\n *\n * @param uri - PostgreSQL connection URI\n * @returns Object containing the target database name and client instance\n *\n * @example\n * ```typescript\n * const { database, db } = await setupClient('postgresql://user:pass@localhost:5432/mydb');\n * // database = 'mydb'\n * // db = Client instance connected to 'postgres' database\n * ```\n */\nasync function setupClient(uri: string) {\n\tconst url = new URL(uri);\n\n\tconst db = new Client({\n\t\tuser: url.username,\n\t\tpassword: url.password,\n\t\thost: url.hostname,\n\t\tport: parseInt(url.port, 10),\n\t\tdatabase: 'postgres',\n\t});\n\n\tlet database = url.pathname.slice(1);\n\tif (database.includes('?')) {\n\t\tdatabase = database.substring(0, database.indexOf('?'));\n\t}\n\treturn { database, db };\n}\n\n/**\n * Default logger instance for migration operations.\n */\nconst logger = console;\n\n/**\n * Abstract base class for PostgreSQL database migration utilities.\n * Provides database creation, migration, and cleanup functionality for testing.\n * Subclasses must implement the migrate() method to define migration logic.\n *\n * @example\n * ```typescript\n * class MyMigrator extends PostgresMigrator {\n *   async migrate(): Promise<void> {\n *     // Run your migrations here\n *     await this.runMigrations();\n *   }\n * }\n *\n * // Use in tests\n * const migrator = new MyMigrator('postgresql://localhost:5432/test_db');\n * const cleanup = await migrator.start();\n *\n * // Run tests...\n *\n * // Clean up\n * await cleanup();\n * ```\n */\nexport abstract class PostgresMigrator {\n\t/**\n\t * Creates a new PostgresMigrator instance.\n\t *\n\t * @param uri - PostgreSQL connection URI\n\t */\n\tconstructor(private uri: string) {}\n\n\t/**\n\t * Abstract method to be implemented by subclasses.\n\t * Should contain the migration logic for setting up database schema.\n\t *\n\t * @returns Promise that resolves when migrations are complete\n\t */\n\tabstract migrate(): Promise<void>;\n\n\t/**\n\t * Creates a PostgreSQL database if it doesn't already exist.\n\t * Connects to the 'postgres' database to check and create the target database.\n\t *\n\t * @param uri - PostgreSQL connection URI\n\t * @returns Object indicating whether the database already existed\n\t * @private\n\t */\n\tprivate static async create(\n\t\turi: string,\n\t): Promise<{ alreadyExisted: boolean }> {\n\t\tconst { database, db } = await setupClient(uri);\n\t\ttry {\n\t\t\tawait db.connect();\n\t\t\tconst result = await db.query(\n\t\t\t\t`SELECT * FROM pg_catalog.pg_database WHERE datname = '${database}'`,\n\t\t\t);\n\n\t\t\tif (result.rowCount === 0) {\n\t\t\t\ttry {\n\t\t\t\t\tawait db.query(`CREATE DATABASE \"${database}\"`);\n\t\t\t\t} catch (error: any) {\n\t\t\t\t\t// 42P04 = duplicate_database — another process created it between our check and create\n\t\t\t\t\tif (error?.code === '42P04') {\n\t\t\t\t\t\treturn { alreadyExisted: true };\n\t\t\t\t\t}\n\t\t\t\t\tthrow error;\n\t\t\t\t}\n\t\t\t}\n\n\t\t\treturn {\n\t\t\t\talreadyExisted: result.rowCount ? result.rowCount > 0 : false,\n\t\t\t};\n\t\t} finally {\n\t\t\tawait db.end();\n\t\t}\n\t}\n\n\t/**\n\t * Drops a PostgreSQL database.\n\t * Used for cleanup after tests are complete.\n\t *\n\t * @param uri - PostgreSQL connection URI\n\t * @throws Error if database cannot be dropped\n\t * @private\n\t */\n\tprivate static async drop(uri: string): Promise<void> {\n\t\tconst { database, db } = await setupClient(uri);\n\t\ttry {\n\t\t\tawait db.connect();\n\t\t\tawait db.query(`DROP DATABASE \"${database}\"`);\n\t\t} finally {\n\t\t\tawait db.end();\n\t\t}\n\t}\n\n\t/**\n\t * Starts the migration process by creating the database and running migrations.\n\t * Returns a cleanup function that will drop the database when called.\n\t *\n\t * @returns Async cleanup function that drops the created database\n\t *\n\t * @example\n\t * ```typescript\n\t * const migrator = new MyMigrator('postgresql://localhost:5432/test_db');\n\t *\n\t * // Start migrations and get cleanup function\n\t * const cleanup = await migrator.start();\n\t *\n\t * try {\n\t *   // Run your tests here\n\t *   await runTests();\n\t * } finally {\n\t *   // Always clean up\n\t *   await cleanup();\n\t * }\n\t * ```\n\t */\n\tasync start() {\n\t\tconst { database, db } = await setupClient(this.uri);\n\t\ttry {\n\t\t\tawait PostgresMigrator.create(this.uri);\n\t\t\t// Implement migration logic here\n\t\t\tawait this.migrate();\n\t\t\tlogger.log(`Migrating database: ${database}`);\n\t\t\t// Example: await db.query('CREATE TABLE example (id SERIAL PRIMARY KEY)');\n\t\t} finally {\n\t\t\tawait db.end();\n\t\t}\n\n\t\treturn async () => {\n\t\t\tawait PostgresMigrator.drop(this.uri);\n\t\t};\n\t}\n}\n"],"mappings":";;;;AAEA,MAAM,EAAE,QAAQ,GAAG;;;;;;;;;;;;;;;AAgBnB,eAAe,YAAYA,KAAa;CACvC,MAAM,MAAM,IAAI,IAAI;CAEpB,MAAM,KAAK,IAAI,OAAO;EACrB,MAAM,IAAI;EACV,UAAU,IAAI;EACd,MAAM,IAAI;EACV,MAAM,SAAS,IAAI,MAAM,GAAG;EAC5B,UAAU;CACV;CAED,IAAI,WAAW,IAAI,SAAS,MAAM,EAAE;AACpC,KAAI,SAAS,SAAS,IAAI,CACzB,YAAW,SAAS,UAAU,GAAG,SAAS,QAAQ,IAAI,CAAC;AAExD,QAAO;EAAE;EAAU;CAAI;AACvB;;;;AAKD,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;AA0Bf,IAAsB,mBAAtB,MAAsB,iBAAiB;;;;;;CAMtC,YAAoBA,KAAa;EAAb;CAAe;;;;;;;;;CAkBnC,aAAqB,OACpBA,KACuC;EACvC,MAAM,EAAE,UAAU,IAAI,GAAG,MAAM,YAAY,IAAI;AAC/C,MAAI;AACH,SAAM,GAAG,SAAS;GAClB,MAAM,SAAS,MAAM,GAAG,OACtB,wDAAwD,SAAS,GAClE;AAED,OAAI,OAAO,aAAa,EACvB,KAAI;AACH,UAAM,GAAG,OAAO,mBAAmB,SAAS,GAAG;GAC/C,SAAQC,OAAY;AAEpB,QAAI,OAAO,SAAS,QACnB,QAAO,EAAE,gBAAgB,KAAM;AAEhC,UAAM;GACN;AAGF,UAAO,EACN,gBAAgB,OAAO,WAAW,OAAO,WAAW,IAAI,MACxD;EACD,UAAS;AACT,SAAM,GAAG,KAAK;EACd;CACD;;;;;;;;;CAUD,aAAqB,KAAKD,KAA4B;EACrD,MAAM,EAAE,UAAU,IAAI,GAAG,MAAM,YAAY,IAAI;AAC/C,MAAI;AACH,SAAM,GAAG,SAAS;AAClB,SAAM,GAAG,OAAO,iBAAiB,SAAS,GAAG;EAC7C,UAAS;AACT,SAAM,GAAG,KAAK;EACd;CACD;;;;;;;;;;;;;;;;;;;;;;;CAwBD,MAAM,QAAQ;EACb,MAAM,EAAE,UAAU,IAAI,GAAG,MAAM,YAAY,KAAK,IAAI;AACpD,MAAI;AACH,SAAM,iBAAiB,OAAO,KAAK,IAAI;AAEvC,SAAM,KAAK,SAAS;AACpB,UAAO,KAAK,sBAAsB,SAAS,EAAE;EAE7C,UAAS;AACT,SAAM,GAAG,KAAK;EACd;AAED,SAAO,YAAY;AAClB,SAAM,iBAAiB,KAAK,KAAK,IAAI;EACrC;CACD;AACD"}

package/dist/PostgresMigrator-DcP1o-T6.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"PostgresMigrator-DcP1o-T6.mjs","names":["uri: string","error: any"],"sources":["../src/PostgresMigrator.ts"],"sourcesContent":["import pg from 'pg';\n\nconst { Client } = pg;\n\n/**\n * Creates a PostgreSQL client connected to the 'postgres' database.\n * Extracts connection details from the provided URI.\n *\n * @param uri - PostgreSQL connection URI\n * @returns Object containing the target database name and client instance\n *\n * @example\n * ```typescript\n * const { database, db } = await setupClient('postgresql://user:pass@localhost:5432/mydb');\n * // database = 'mydb'\n * // db = Client instance connected to 'postgres' database\n * ```\n */\nasync function setupClient(uri: string) {\n\tconst url = new URL(uri);\n\n\tconst db = new Client({\n\t\tuser: url.username,\n\t\tpassword: url.password,\n\t\thost: url.hostname,\n\t\tport: parseInt(url.port, 10),\n\t\tdatabase: 'postgres',\n\t});\n\n\tlet database = url.pathname.slice(1);\n\tif (database.includes('?')) {\n\t\tdatabase = database.substring(0, database.indexOf('?'));\n\t}\n\treturn { database, db };\n}\n\n/**\n * Default logger instance for migration operations.\n */\nconst logger = console;\n\n/**\n * Abstract base class for PostgreSQL database migration utilities.\n * Provides database creation, migration, and cleanup functionality for testing.\n * Subclasses must implement the migrate() method to define migration logic.\n *\n * @example\n * ```typescript\n * class MyMigrator extends PostgresMigrator {\n *   async migrate(): Promise<void> {\n *     // Run your migrations here\n *     await this.runMigrations();\n *   }\n * }\n *\n * // Use in tests\n * const migrator = new MyMigrator('postgresql://localhost:5432/test_db');\n * const cleanup = await migrator.start();\n *\n * // Run tests...\n *\n * // Clean up\n * await cleanup();\n * ```\n */\nexport abstract class PostgresMigrator {\n\t/**\n\t * Creates a new PostgresMigrator instance.\n\t *\n\t * @param uri - PostgreSQL connection URI\n\t */\n\tconstructor(private uri: string) {}\n\n\t/**\n\t * Abstract method to be implemented by subclasses.\n\t * Should contain the migration logic for setting up database schema.\n\t *\n\t * @returns Promise that resolves when migrations are complete\n\t */\n\tabstract migrate(): Promise<void>;\n\n\t/**\n\t * Creates a PostgreSQL database if it doesn't already exist.\n\t * Connects to the 'postgres' database to check and create the target database.\n\t *\n\t * @param uri - PostgreSQL connection URI\n\t * @returns Object indicating whether the database already existed\n\t * @private\n\t */\n\tprivate static async create(\n\t\turi: string,\n\t): Promise<{ alreadyExisted: boolean }> {\n\t\tconst { database, db } = await setupClient(uri);\n\t\ttry {\n\t\t\tawait db.connect();\n\t\t\tconst result = await db.query(\n\t\t\t\t`SELECT * FROM pg_catalog.pg_database WHERE datname = '${database}'`,\n\t\t\t);\n\n\t\t\tif (result.rowCount === 0) {\n\t\t\t\ttry {\n\t\t\t\t\tawait db.query(`CREATE DATABASE \"${database}\"`);\n\t\t\t\t} catch (error: any) {\n\t\t\t\t\t// 42P04 = duplicate_database — another process created it between our check and create\n\t\t\t\t\tif (error?.code === '42P04') {\n\t\t\t\t\t\treturn { alreadyExisted: true };\n\t\t\t\t\t}\n\t\t\t\t\tthrow error;\n\t\t\t\t}\n\t\t\t}\n\n\t\t\treturn {\n\t\t\t\talreadyExisted: result.rowCount ? result.rowCount > 0 : false,\n\t\t\t};\n\t\t} finally {\n\t\t\tawait db.end();\n\t\t}\n\t}\n\n\t/**\n\t * Drops a PostgreSQL database.\n\t * Used for cleanup after tests are complete.\n\t *\n\t * @param uri - PostgreSQL connection URI\n\t * @throws Error if database cannot be dropped\n\t * @private\n\t */\n\tprivate static async drop(uri: string): Promise<void> {\n\t\tconst { database, db } = await setupClient(uri);\n\t\ttry {\n\t\t\tawait db.connect();\n\t\t\tawait db.query(`DROP DATABASE \"${database}\"`);\n\t\t} finally {\n\t\t\tawait db.end();\n\t\t}\n\t}\n\n\t/**\n\t * Starts the migration process by creating the database and running migrations.\n\t * Returns a cleanup function that will drop the database when called.\n\t *\n\t * @returns Async cleanup function that drops the created database\n\t *\n\t * @example\n\t * ```typescript\n\t * const migrator = new MyMigrator('postgresql://localhost:5432/test_db');\n\t *\n\t * // Start migrations and get cleanup function\n\t * const cleanup = await migrator.start();\n\t *\n\t * try {\n\t *   // Run your tests here\n\t *   await runTests();\n\t * } finally {\n\t *   // Always clean up\n\t *   await cleanup();\n\t * }\n\t * ```\n\t */\n\tasync start() {\n\t\tconst { database, db } = await setupClient(this.uri);\n\t\ttry {\n\t\t\tawait PostgresMigrator.create(this.uri);\n\t\t\t// Implement migration logic here\n\t\t\tawait this.migrate();\n\t\t\tlogger.log(`Migrating database: ${database}`);\n\t\t\t// Example: await db.query('CREATE TABLE example (id SERIAL PRIMARY KEY)');\n\t\t} finally {\n\t\t\tawait db.end();\n\t\t}\n\n\t\treturn async () => {\n\t\t\tawait PostgresMigrator.drop(this.uri);\n\t\t};\n\t}\n}\n"],"mappings":";;;AAEA,MAAM,EAAE,QAAQ,GAAG;;;;;;;;;;;;;;;AAgBnB,eAAe,YAAYA,KAAa;CACvC,MAAM,MAAM,IAAI,IAAI;CAEpB,MAAM,KAAK,IAAI,OAAO;EACrB,MAAM,IAAI;EACV,UAAU,IAAI;EACd,MAAM,IAAI;EACV,MAAM,SAAS,IAAI,MAAM,GAAG;EAC5B,UAAU;CACV;CAED,IAAI,WAAW,IAAI,SAAS,MAAM,EAAE;AACpC,KAAI,SAAS,SAAS,IAAI,CACzB,YAAW,SAAS,UAAU,GAAG,SAAS,QAAQ,IAAI,CAAC;AAExD,QAAO;EAAE;EAAU;CAAI;AACvB;;;;AAKD,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;AA0Bf,IAAsB,mBAAtB,MAAsB,iBAAiB;;;;;;CAMtC,YAAoBA,KAAa;EAAb;CAAe;;;;;;;;;CAkBnC,aAAqB,OACpBA,KACuC;EACvC,MAAM,EAAE,UAAU,IAAI,GAAG,MAAM,YAAY,IAAI;AAC/C,MAAI;AACH,SAAM,GAAG,SAAS;GAClB,MAAM,SAAS,MAAM,GAAG,OACtB,wDAAwD,SAAS,GAClE;AAED,OAAI,OAAO,aAAa,EACvB,KAAI;AACH,UAAM,GAAG,OAAO,mBAAmB,SAAS,GAAG;GAC/C,SAAQC,OAAY;AAEpB,QAAI,OAAO,SAAS,QACnB,QAAO,EAAE,gBAAgB,KAAM;AAEhC,UAAM;GACN;AAGF,UAAO,EACN,gBAAgB,OAAO,WAAW,OAAO,WAAW,IAAI,MACxD;EACD,UAAS;AACT,SAAM,GAAG,KAAK;EACd;CACD;;;;;;;;;CAUD,aAAqB,KAAKD,KAA4B;EACrD,MAAM,EAAE,UAAU,IAAI,GAAG,MAAM,YAAY,IAAI;AAC/C,MAAI;AACH,SAAM,GAAG,SAAS;AAClB,SAAM,GAAG,OAAO,iBAAiB,SAAS,GAAG;EAC7C,UAAS;AACT,SAAM,GAAG,KAAK;EACd;CACD;;;;;;;;;;;;;;;;;;;;;;;CAwBD,MAAM,QAAQ;EACb,MAAM,EAAE,UAAU,IAAI,GAAG,MAAM,YAAY,KAAK,IAAI;AACpD,MAAI;AACH,SAAM,iBAAiB,OAAO,KAAK,IAAI;AAEvC,SAAM,KAAK,SAAS;AACpB,UAAO,KAAK,sBAAsB,SAAS,EAAE;EAE7C,UAAS;AACT,SAAM,GAAG,KAAK;EACd;AAED,SAAO,YAAY;AAClB,SAAM,iBAAiB,KAAK,KAAK,IAAI;EACrC;CACD;AACD"}

package/dist/PostgresMigrator-S-YYosAC.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"PostgresMigrator-S-YYosAC.d.mts","names":[],"sources":["../src/PostgresMigrator.ts"],"sourcesContent":[],"mappings":";;AAiEA;;;;;AA8FY;;;;;;;;;;;;;;;;;;uBA9FU,gBAAA;;;;;;;;;;;;;;sBAcD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WAgFT,cAAA"}