@geekmidas/testkit 10.0.0-alpha.3 → 10.0.0-alpha.31

package/dist/PostgresKyselyMigrator.d.cts

@@ -1,3 +1,80 @@
-import "./PostgresMigrator-CeYy-eHF.cjs";
-import { PostgresKyselyMigrator } from "./PostgresKyselyMigrator-B2M6Gjvv.cjs";
-export { PostgresKyselyMigrator };
+import { t as PostgresMigrator } from "./PostgresMigrator-CDPnnwMJ.cjs";
+import { Kysely } from "kysely";
+import { MigrationProvider } from "kysely/migration";
+//#region src/PostgresKyselyMigrator.d.ts
+/**
+ * PostgreSQL migrator implementation for Kysely ORM.
+ * Extends PostgresMigrator to provide Kysely-specific migration functionality.
+ * Automatically creates test databases and applies migrations for testing environments.
+ *
+ * @example
+ * ```typescript
+ * import { FileMigrationProvider } from 'kysely';
+ * import { PostgresKyselyMigrator } from '@geekmidas/testkit';
+ *
+ * // Create migration provider
+ * const provider = new FileMigrationProvider({
+ *   fs: require('fs'),
+ *   path: require('path'),
+ *   migrationFolder: path.join(__dirname, 'migrations')
+ * });
+ *
+ * // Create Kysely instance
+ * const db = new Kysely<Database>({
+ *   dialect: new PostgresDialect({
+ *     pool: new Pool({ connectionString: uri })
+ *   })
+ * });
+ *
+ * // Create and use migrator
+ * const migrator = new PostgresKyselyMigrator({
+ *   uri: 'postgresql://localhost:5432/test_db',
+ *   db,
+ *   provider
+ * });
+ *
+ * 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 declare class PostgresKyselyMigrator extends PostgresMigrator {
+  private options;
+  /**
+   * Creates a new PostgresKyselyMigrator instance.
+   *
+   * @param options - Configuration options
+   * @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(options: {
+    uri: string;
+    db: Kysely<any>;
+    provider: MigrationProvider;
+    afterCreate?: (uri: string) => Promise<void>;
+  });
+  /**
+   * Executes Kysely migrations to the latest version.
+   * Implements the abstract migrate() method from PostgresMigrator.
+   *
+   * @throws Error if migrations fail to apply
+   * @returns Promise that resolves when all migrations are applied
+   */
+  migrate(): Promise<void>;
+}
+//#endregion
+//# sourceMappingURL=PostgresKyselyMigrator.d.cts.map

package/dist/PostgresKyselyMigrator.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PostgresKyselyMigrator.d.cts","names":[],"sources":["../src/PostgresKyselyMigrator.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBA2Da,+BAA+B;UAWlC;;;;;;;;;;EADT,YACS;IACP;IACA,IAAI;IACJ,UAAU;IACV,eAAe,gBAAgB;;;;;;;;;EAa3B,WAAW"}

package/dist/PostgresKyselyMigrator.d.mts

@@ -1,3 +1,80 @@
-import "./PostgresMigrator-C_QQ6q35.mjs";
-import { PostgresKyselyMigrator } from "./PostgresKyselyMigrator-CvwXycJE.mjs";
-export { PostgresKyselyMigrator };
+import { t as PostgresMigrator } from "./PostgresMigrator-CDPnnwMJ.mjs";
+import { MigrationProvider } from "kysely/migration";
+import { Kysely } from "kysely";
+//#region src/PostgresKyselyMigrator.d.ts
+/**
+ * PostgreSQL migrator implementation for Kysely ORM.
+ * Extends PostgresMigrator to provide Kysely-specific migration functionality.
+ * Automatically creates test databases and applies migrations for testing environments.
+ *
+ * @example
+ * ```typescript
+ * import { FileMigrationProvider } from 'kysely';
+ * import { PostgresKyselyMigrator } from '@geekmidas/testkit';
+ *
+ * // Create migration provider
+ * const provider = new FileMigrationProvider({
+ *   fs: require('fs'),
+ *   path: require('path'),
+ *   migrationFolder: path.join(__dirname, 'migrations')
+ * });
+ *
+ * // Create Kysely instance
+ * const db = new Kysely<Database>({
+ *   dialect: new PostgresDialect({
+ *     pool: new Pool({ connectionString: uri })
+ *   })
+ * });
+ *
+ * // Create and use migrator
+ * const migrator = new PostgresKyselyMigrator({
+ *   uri: 'postgresql://localhost:5432/test_db',
+ *   db,
+ *   provider
+ * });
+ *
+ * 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 declare class PostgresKyselyMigrator extends PostgresMigrator {
+  private options;
+  /**
+   * Creates a new PostgresKyselyMigrator instance.
+   *
+   * @param options - Configuration options
+   * @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(options: {
+    uri: string;
+    db: Kysely<any>;
+    provider: MigrationProvider;
+    afterCreate?: (uri: string) => Promise<void>;
+  });
+  /**
+   * Executes Kysely migrations to the latest version.
+   * Implements the abstract migrate() method from PostgresMigrator.
+   *
+   * @throws Error if migrations fail to apply
+   * @returns Promise that resolves when all migrations are applied
+   */
+  migrate(): Promise<void>;
+}
+//#endregion
+//# sourceMappingURL=PostgresKyselyMigrator.d.mts.map

package/dist/PostgresKyselyMigrator.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PostgresKyselyMigrator.d.mts","names":[],"sources":["../src/PostgresKyselyMigrator.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBA2Da,+BAA+B;UAWlC;;;;;;;;;;EADT,YACS;IACP;IACA,IAAI;IACJ,UAAU;IACV,eAAe,gBAAgB;;;;;;;;;EAa3B,WAAW"}

package/dist/PostgresKyselyMigrator.mjs

@@ -1,4 +1,94 @@
-import "./PostgresMigrator-DVAY04qN.mjs";
-import { PostgresKyselyMigrator } from "./PostgresKyselyMigrator-PI0QhvB1.mjs";
+import { PostgresMigrator } from "./PostgresMigrator.mjs";
+import { Migrator } from "kysely/migration";
+//#region src/PostgresKyselyMigrator.ts
+/**
+* Default logger instance for migration operations.
+*/
+const logger = console;
+/**
+* PostgreSQL migrator implementation for Kysely ORM.
+* Extends PostgresMigrator to provide Kysely-specific migration functionality.
+* Automatically creates test databases and applies migrations for testing environments.
+*
+* @example
+* ```typescript
+* import { FileMigrationProvider } from 'kysely';
+* import { PostgresKyselyMigrator } from '@geekmidas/testkit';
+*
+* // Create migration provider
+* const provider = new FileMigrationProvider({
+*   fs: require('fs'),
+*   path: require('path'),
+*   migrationFolder: path.join(__dirname, 'migrations')
+* });
+*
+* // Create Kysely instance
+* const db = new Kysely<Database>({
+*   dialect: new PostgresDialect({
+*     pool: new Pool({ connectionString: uri })
+*   })
+* });
+*
+* // Create and use migrator
+* const migrator = new PostgresKyselyMigrator({
+*   uri: 'postgresql://localhost:5432/test_db',
+*   db,
+*   provider
+* });
+*
+* 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);
+*   },
+* });
+* ```
+*/
+var PostgresKyselyMigrator = class extends PostgresMigrator {
+	options;
+	/**
+	* Creates a new PostgresKyselyMigrator instance.
+	*
+	* @param options - Configuration options
+	* @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(options) {
+		super(options.uri, options.afterCreate);
+		this.options = options;
+	}
+	/**
+	* Executes Kysely migrations to the latest version.
+	* Implements the abstract migrate() method from PostgresMigrator.
+	*
+	* @throws Error if migrations fail to apply
+	* @returns Promise that resolves when all migrations are applied
+	*/
+	async migrate() {
+		const migrations = await new Migrator({
+			db: this.options.db,
+			provider: this.options.provider
+		}).migrateToLatest();
+		if (migrations.error) {
+			logger.error(migrations.error, `Failed to apply migrations`);
+			throw migrations.error;
+		}
+		await this.options.db.destroy();
+		logger.log(`Applied ${migrations.results?.length} migrations successfully`);
+	}
+};
+//#endregion
+export { PostgresKyselyMigrator };
 
-export { PostgresKyselyMigrator };
+//# sourceMappingURL=PostgresKyselyMigrator.mjs.map

package/dist/PostgresKyselyMigrator.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"PostgresKyselyMigrator.mjs","names":[],"sources":["../src/PostgresKyselyMigrator.ts"],"sourcesContent":["import type { Kysely } from 'kysely';\n// `Migrator` and the `MigrationProvider` type moved from the root barrel ('kysely')\n// to the 'kysely/migration' subpath in kysely 0.29+.\nimport { type MigrationProvider, Migrator } from 'kysely/migration';\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 * // With afterCreate hook to create per-app users\n * import { runInitScript } from '@geekmidas/testkit/postgres';\n *\n * const migrator = new PostgresKyselyMigrator({\n *   uri: 'postgresql://localhost:5432/test_db',\n *   db,\n *   provider,\n *   afterCreate: async (uri) => {\n *     await runInitScript('docker/postgres/init.sh', uri, env);\n *   },\n * });\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 * @param options.afterCreate - Optional hook called after database creation but before migrations\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\tafterCreate?: (uri: string) => Promise<void>;\n\t\t},\n\t) {\n\t\tsuper(options.uri, options.afterCreate);\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":";;;;;;AASA,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkDf,IAAa,yBAAb,cAA4C,iBAAiB;CAWnD;;;;;;;;;;CADT,YACC,SAMC;EACD,MAAM,QAAQ,KAAK,QAAQ,WAAW;EAP9B,KAAA,UAAA;CAQT;;;;;;;;CASA,MAAM,UAAyB;EAK9B,MAAM,aAAa,MAAM,IAJJ,SAAS;GAC7B,IAAI,KAAK,QAAQ;GACjB,UAAU,KAAK,QAAQ;EACxB,CACgC,CAAC,CAAC,gBAAgB;EAElD,IAAI,WAAW,OAAO;GACrB,OAAO,MAAM,WAAW,OAAO,4BAA4B;GAC3D,MAAM,WAAW;EAClB;EAEA,MAAM,KAAK,QAAQ,GAAG,QAAQ;EAE9B,OAAO,IAAI,WAAW,WAAW,SAAS,OAAO,yBAAyB;CAC3E;AACD"}

package/dist/{PostgresMigrator-C_QQ6q35.d.mts → PostgresMigrator-CDPnnwMJ.d.cts}

@@ -71,9 +71,16 @@ declare abstract class PostgresMigrator {
   private static drop;
   /**
    * Starts the migration process by creating the database and running migrations.
-   * Returns a cleanup function that will drop the database when called.
+   * Returns a cleanup function that drops the database — if this call created
+   * it.
    *
-   * @returns Async cleanup function that drops the created database
+   * A database that was already there belongs to whoever made it, and the
+   * cleanup leaves it alone. `gkm test` provisions the test database before
+   * the suite starts, with an owner role that may migrate it but not drop it:
+   * dropping it was never the suite's to do, and failed there as a permission
+   * error on the way out of an otherwise green run.
+   *
+   * @returns Async cleanup function that drops the database if it created it
    *
    * @example
    * ```typescript
@@ -93,7 +100,6 @@ declare abstract class PostgresMigrator {
    */
   start(): Promise<() => Promise<void>>;
 }
-//# sourceMappingURL=PostgresMigrator.d.ts.map
 //#endregion
-export { PostgresMigrator };
-//# sourceMappingURL=PostgresMigrator-C_QQ6q35.d.mts.map
+export { PostgresMigrator as t };
+//# sourceMappingURL=PostgresMigrator-CDPnnwMJ.d.cts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"PostgresMigrator-CDPnnwMJ.d.cts","names":[],"sources":["../src/PostgresMigrator.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uBA4EsB;UAQZ;UACA;;;;;;;EAFT,YACS,aACA,gBAAe,gBAAgB;;;;;;;WAS/B,WAAW;;;;;;;;;iBAUC;;;;;;;;;iBAsCA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAuCf,SAAK,cAAA"}

package/dist/{PostgresMigrator-CeYy-eHF.d.cts → PostgresMigrator-CDPnnwMJ.d.mts}

@@ -71,9 +71,16 @@ declare abstract class PostgresMigrator {
   private static drop;
   /**
    * Starts the migration process by creating the database and running migrations.
-   * Returns a cleanup function that will drop the database when called.
+   * Returns a cleanup function that drops the database — if this call created
+   * it.
    *
-   * @returns Async cleanup function that drops the created database
+   * A database that was already there belongs to whoever made it, and the
+   * cleanup leaves it alone. `gkm test` provisions the test database before
+   * the suite starts, with an owner role that may migrate it but not drop it:
+   * dropping it was never the suite's to do, and failed there as a permission
+   * error on the way out of an otherwise green run.
+   *
+   * @returns Async cleanup function that drops the database if it created it
    *
    * @example
    * ```typescript
@@ -93,7 +100,6 @@ declare abstract class PostgresMigrator {
    */
   start(): Promise<() => Promise<void>>;
 }
-//# sourceMappingURL=PostgresMigrator.d.ts.map
 //#endregion
-export { PostgresMigrator };
-//# sourceMappingURL=PostgresMigrator-CeYy-eHF.d.cts.map
+export { PostgresMigrator as t };
+//# sourceMappingURL=PostgresMigrator-CDPnnwMJ.d.mts.map

package/dist/PostgresMigrator-CDPnnwMJ.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PostgresMigrator-CDPnnwMJ.d.mts","names":[],"sources":["../src/PostgresMigrator.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uBA4EsB;UAQZ;UACA;;;;;;;EAFT,YACS,aACA,gBAAe,gBAAgB;;;;;;;WAS/B,WAAW;;;;;;;;;iBAUC;;;;;;;;;iBAsCA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAuCf,SAAK,cAAA"}

package/dist/PostgresMigrator.cjs

@@ -1,3 +1,179 @@
-const require_PostgresMigrator = require('./PostgresMigrator-M9jpzOvN.cjs');
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_rolldown_runtime = require("./rolldown-runtime-VH7oDXx4.cjs");
+let pg = require("pg");
+pg = require_rolldown_runtime.__toESM(pg, 1);
+//#region src/PostgresMigrator.ts
+const { Client } = pg.default;
+/**
+* Creates a PostgreSQL client connected to the 'postgres' database.
+* Extracts connection details from the provided URI.
+*
+* @param uri - PostgreSQL connection URI
+* @returns Object containing the target database name and client instance
+*
+* @example
+* ```typescript
+* const { database, db } = await setupClient('postgresql://user:pass@localhost:5432/mydb');
+* // database = 'mydb'
+* // db = Client instance connected to 'postgres' database
+* ```
+*/
+async function setupClient(uri) {
+	const url = new URL(uri);
+	const db = new Client({
+		user: url.username,
+		password: url.password,
+		host: url.hostname,
+		port: parseInt(url.port, 10),
+		database: "postgres"
+	});
+	let database = url.pathname.slice(1);
+	if (database.includes("?")) database = database.substring(0, database.indexOf("?"));
+	return {
+		database,
+		db
+	};
+}
+/**
+* Default logger instance for migration operations.
+*/
+const logger = console;
+/**
+* Abstract base class for PostgreSQL database migration utilities.
+* Provides database creation, migration, and cleanup functionality for testing.
+* Subclasses must implement the migrate() method to define migration logic.
+*
+* @example
+* ```typescript
+* class MyMigrator extends PostgresMigrator {
+*   async migrate(): Promise<void> {
+*     // Run your migrations here
+*     await this.runMigrations();
+*   }
+* }
+*
+* // Use in tests
+* 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
+* await cleanup();
+* ```
+*/
+var PostgresMigrator = class PostgresMigrator {
+	uri;
+	afterCreate;
+	/**
+	* Creates a new PostgresMigrator instance.
+	*
+	* @param uri - PostgreSQL connection URI
+	* @param afterCreate - Optional hook called after database creation but before migrations
+	*/
+	constructor(uri, afterCreate) {
+		this.uri = uri;
+		this.afterCreate = afterCreate;
+	}
+	/**
+	* Creates a PostgreSQL database if it doesn't already exist.
+	* Connects to the 'postgres' database to check and create the target database.
+	*
+	* @param uri - PostgreSQL connection URI
+	* @returns Object indicating whether the database already existed
+	* @private
+	*/
+	static async create(uri) {
+		const { database, db } = await setupClient(uri);
+		try {
+			await db.connect();
+			const result = await db.query(`SELECT * FROM pg_catalog.pg_database WHERE datname = '${database}'`);
+			if (result.rowCount === 0) try {
+				await db.query(`CREATE DATABASE "${database}"`);
+			} catch (error) {
+				if (error?.code === "42P04") return { alreadyExisted: true };
+				throw error;
+			}
+			return { alreadyExisted: result.rowCount ? result.rowCount > 0 : false };
+		} finally {
+			await db.end();
+		}
+	}
+	/**
+	* Drops a PostgreSQL database.
+	* Used for cleanup after tests are complete.
+	*
+	* @param uri - PostgreSQL connection URI
+	* @throws Error if database cannot be dropped
+	* @private
+	*/
+	static async drop(uri) {
+		const { database, db } = await setupClient(uri);
+		try {
+			await db.connect();
+			await db.query(`DROP DATABASE "${database}"`);
+		} finally {
+			await db.end();
+		}
+	}
+	/**
+	* Starts the migration process by creating the database and running migrations.
+	* Returns a cleanup function that drops the database — if this call created
+	* it.
+	*
+	* A database that was already there belongs to whoever made it, and the
+	* cleanup leaves it alone. `gkm test` provisions the test database before
+	* the suite starts, with an owner role that may migrate it but not drop it:
+	* dropping it was never the suite's to do, and failed there as a permission
+	* error on the way out of an otherwise green run.
+	*
+	* @returns Async cleanup function that drops the database if it created it
+	*
+	* @example
+	* ```typescript
+	* const migrator = new MyMigrator('postgresql://localhost:5432/test_db');
+	*
+	* // Start migrations and get cleanup function
+	* const cleanup = await migrator.start();
+	*
+	* try {
+	*   // Run your tests here
+	*   await runTests();
+	* } finally {
+	*   // Always clean up
+	*   await cleanup();
+	* }
+	* ```
+	*/
+	async start() {
+		const { database, db } = await setupClient(this.uri);
+		let created = false;
+		try {
+			const { alreadyExisted } = await PostgresMigrator.create(this.uri);
+			created = !alreadyExisted;
+			if (this.afterCreate) await this.afterCreate(this.uri);
+			await this.migrate();
+			logger.log(`Migrating database: ${database}`);
+		} finally {
+			await db.end();
+		}
+		return async () => {
+			if (created) await PostgresMigrator.drop(this.uri);
+		};
+	}
+};
+//#endregion
+exports.PostgresMigrator = PostgresMigrator;
 
-exports.PostgresMigrator = require_PostgresMigrator.PostgresMigrator;
+//# sourceMappingURL=PostgresMigrator.cjs.map

package/dist/PostgresMigrator.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"PostgresMigrator.cjs","names":[],"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 * // With afterCreate hook (e.g. run init script to create per-app users)\n * import { runInitScript } from '@geekmidas/testkit/postgres';\n *\n * const migrator = new MyMigrator(\n *   'postgresql://localhost:5432/test_db',\n *   async (uri) => {\n *     await runInitScript('docker/postgres/init.sh', uri, env);\n *   },\n * );\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 * @param afterCreate - Optional hook called after database creation but before migrations\n\t */\n\tconstructor(\n\t\tprivate uri: string,\n\t\tprivate afterCreate?: (uri: string) => Promise<void>,\n\t) {}\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 drops the database — if this call created\n\t * it.\n\t *\n\t * A database that was already there belongs to whoever made it, and the\n\t * cleanup leaves it alone. `gkm test` provisions the test database before\n\t * the suite starts, with an owner role that may migrate it but not drop it:\n\t * dropping it was never the suite's to do, and failed there as a permission\n\t * error on the way out of an otherwise green run.\n\t *\n\t * @returns Async cleanup function that drops the database if it created it\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\tlet created = false;\n\t\ttry {\n\t\t\tconst { alreadyExisted } = await PostgresMigrator.create(this.uri);\n\t\t\tcreated = !alreadyExisted;\n\t\t\tif (this.afterCreate) {\n\t\t\t\tawait this.afterCreate(this.uri);\n\t\t\t}\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\tif (created) await PostgresMigrator.drop(this.uri);\n\t\t};\n\t}\n}\n"],"mappings":";;;;;AAEA,MAAM,EAAE,WAAW,GAAA;;;;;;;;;;;;;;;AAgBnB,eAAe,YAAY,KAAa;CACvC,MAAM,MAAM,IAAI,IAAI,GAAG;CAEvB,MAAM,KAAK,IAAI,OAAO;EACrB,MAAM,IAAI;EACV,UAAU,IAAI;EACd,MAAM,IAAI;EACV,MAAM,SAAS,IAAI,MAAM,EAAE;EAC3B,UAAU;CACX,CAAC;CAED,IAAI,WAAW,IAAI,SAAS,MAAM,CAAC;CACnC,IAAI,SAAS,SAAS,GAAG,GACxB,WAAW,SAAS,UAAU,GAAG,SAAS,QAAQ,GAAG,CAAC;CAEvD,OAAO;EAAE;EAAU;CAAG;AACvB;;;;AAKA,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAqCf,IAAsB,mBAAtB,MAAsB,iBAAiB;CAQ7B;CACA;;;;;;;CAFT,YACC,KACA,aACC;EAFO,KAAA,MAAA;EACA,KAAA,cAAA;CACN;;;;;;;;;CAkBH,aAAqB,OACpB,KACuC;EACvC,MAAM,EAAE,UAAU,OAAO,MAAM,YAAY,GAAG;EAC9C,IAAI;GACH,MAAM,GAAG,QAAQ;GACjB,MAAM,SAAS,MAAM,GAAG,MACvB,yDAAyD,SAAS,EACnE;GAEA,IAAI,OAAO,aAAa,GACvB,IAAI;IACH,MAAM,GAAG,MAAM,oBAAoB,SAAS,EAAE;GAC/C,SAAS,OAAY;IAEpB,IAAI,OAAO,SAAS,SACnB,OAAO,EAAE,gBAAgB,KAAK;IAE/B,MAAM;GACP;GAGD,OAAO,EACN,gBAAgB,OAAO,WAAW,OAAO,WAAW,IAAI,MACzD;EACD,UAAU;GACT,MAAM,GAAG,IAAI;EACd;CACD;;;;;;;;;CAUA,aAAqB,KAAK,KAA4B;EACrD,MAAM,EAAE,UAAU,OAAO,MAAM,YAAY,GAAG;EAC9C,IAAI;GACH,MAAM,GAAG,QAAQ;GACjB,MAAM,GAAG,MAAM,kBAAkB,SAAS,EAAE;EAC7C,UAAU;GACT,MAAM,GAAG,IAAI;EACd;CACD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+BA,MAAM,QAAQ;EACb,MAAM,EAAE,UAAU,OAAO,MAAM,YAAY,KAAK,GAAG;EACnD,IAAI,UAAU;EACd,IAAI;GACH,MAAM,EAAE,mBAAmB,MAAM,iBAAiB,OAAO,KAAK,GAAG;GACjE,UAAU,CAAC;GACX,IAAI,KAAK,aACR,MAAM,KAAK,YAAY,KAAK,GAAG;GAEhC,MAAM,KAAK,QAAQ;GACnB,OAAO,IAAI,uBAAuB,UAAU;EAE7C,UAAU;GACT,MAAM,GAAG,IAAI;EACd;EAEA,OAAO,YAAY;GAClB,IAAI,SAAS,MAAM,iBAAiB,KAAK,KAAK,GAAG;EAClD;CACD;AACD"}

package/dist/PostgresMigrator.d.cts

@@ -1,2 +1,2 @@
-import { PostgresMigrator } from "./PostgresMigrator-CeYy-eHF.cjs";
+import { t as PostgresMigrator } from "./PostgresMigrator-CDPnnwMJ.cjs";
 export { PostgresMigrator };

package/dist/PostgresMigrator.d.mts

@@ -1,2 +1,2 @@
-import { PostgresMigrator } from "./PostgresMigrator-C_QQ6q35.mjs";
+import { t as PostgresMigrator } from "./PostgresMigrator-CDPnnwMJ.mjs";
 export { PostgresMigrator };