@seedcord/plugins 0.3.3 → 0.4.1

package/dist/index.mjs

@@ -1,30 +1,37 @@
-import mongoose2 from 'mongoose';
 import 'reflect-metadata';
-import chalk from 'chalk';
+import chalk3 from 'chalk';
 import { Envapter } from 'envapt';
-import { Plugin, Logger, ShutdownPhase, traverseDirectory, CustomError, throwCustomError, DatabaseError } from 'seedcord';
+import mongoose from 'mongoose';
+import { Plugin, Logger, ShutdownPhase, traverseDirectory, keepDefined as keepDefined$1, CustomError, throwCustomError, DatabaseError } from 'seedcord';
+import { Pool } from 'pg';
+import { promises } from 'fs';
+import path from 'path';
+import { pathToFileURL } from 'url';
+import { inspect } from 'util';
+import { keepDefined } from '@seedcord/utils';
+import { Migrator, FileMigrationProvider, Kysely, PostgresDialect, NO_MIGRATIONS } from 'kysely';
 
 var __defProp = Object.defineProperty;
 var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+
+// src/mongo/decorators/RegisterMongoService.ts
+var ServiceMetadataKey = Symbol("db:serviceKey");
+function RegisterMongoService(key) {
+  return (ctor) => {
+    Reflect.defineMetadata(ServiceMetadataKey, key, ctor);
+  };
+}
+__name(RegisterMongoService, "RegisterMongoService");
 var ModelMetadataKey = Symbol("db:model");
-function DatabaseModel(collection) {
+function RegisterMongoModel(collection) {
   return (target, propertyKey) => {
     const schema = target[propertyKey];
     const name = String(collection);
-    const model = mongoose2.model(name, schema);
+    const model = mongoose.model(name, schema);
     Reflect.defineMetadata(ModelMetadataKey, model, target);
   };
 }
-__name(DatabaseModel, "DatabaseModel");
-
-// src/mongo/decorators/DatabaseService.ts
-var ServiceMetadataKey = Symbol("db:serviceKey");
-function DatabaseService(key) {
-  return (ctor) => {
-    Reflect.defineMetadata(ServiceMetadataKey, key, ctor);
-  };
-}
-__name(DatabaseService, "DatabaseService");
+__name(RegisterMongoModel, "RegisterMongoModel");
 
 // src/mongo/MongoService.ts
 var MongoService = class {
@@ -39,13 +46,15 @@ var MongoService = class {
     this.core = core;
     const ctor = this.constructor;
     const key = Reflect.getMetadata(ServiceMetadataKey, ctor);
-    if (!key) throw new Error(`Missing @DatabaseService on ${ctor.name}`);
+    if (!key) throw new Error(`Missing @RegisterMongoService on ${ctor.name}`);
     const model = Reflect.getMetadata(ModelMetadataKey, ctor);
-    if (!model) throw new Error(`Missing @DatabaseModel on ${ctor.name}`);
+    if (!model) throw new Error(`Missing @RegisterMongoModel on ${ctor.name}`);
     this.model = model;
     db._register(key, this);
   }
 };
+
+// src/mongo/Mongo.ts
 var Mongo = class extends Plugin {
   static {
     __name(this, "Mongo");
@@ -57,7 +66,7 @@ var Mongo = class extends Plugin {
   uri;
   /**
    * Map of all loaded services.
-   * Keys come from `@DatabaseService('key')`
+   * Keys come from `@RegisterMongoService('key')`
    */
   services = {};
   constructor(core, options) {
@@ -75,40 +84,662 @@ var Mongo = class extends Plugin {
     await this.disconnect();
   }
   async connect() {
-    await mongoose2.connect(this.uri, {
+    this.connection = await mongoose.connect(this.uri, {
       dbName: this.options.name,
       ...Envapter.isProduction && {
         tls: true,
         ssl: true
       }
-    }).then((i) => this.logger.info(`Connected to MongoDB: ${chalk.bold.magenta(i.connection.name)}`)).catch((err) => {
+    }).then((conn) => {
+      this.logger.info(chalk3.green.bold(`Connected to MongoDB: ${chalk3.magenta.bold(conn.connection.name)}`));
+      return conn;
+    }).catch((err) => {
       throw new Error(`Could not connect to MongoDB`, err);
     });
   }
   async disconnect() {
-    await mongoose2.disconnect().then(() => this.logger.info(chalk.red.bold("Disconnected from MongoDB"))).catch((err) => this.logger.error(`Could not disconnect from MongoDB: ${err.message}`));
+    await this.connection.disconnect().then(() => this.logger.info(chalk3.red.bold("Disconnected from MongoDB"))).catch((err) => this.logger.error(`Could not disconnect from MongoDB: ${err.message}`));
   }
   async loadServices() {
     const servicesDir = this.options.dir;
-    this.logger.info(chalk.bold(servicesDir));
+    this.logger.info(chalk3.bold(servicesDir));
     await traverseDirectory(servicesDir, (_full, rel, mod) => {
       for (const Service of Object.values(mod)) {
         if (this.isServiceClass(Service)) {
           const instance = new Service(this, this.core);
-          this.logger.info(`${chalk.italic("Registered")} ${chalk.bold.yellow(instance.constructor.name)} from ${chalk.gray(rel)}`);
+          this.logger.info(`${chalk3.italic("Registered")} ${chalk3.bold.yellow(instance.constructor.name)} from ${chalk3.gray(rel)}`);
         }
       }
     }, this.logger);
-    this.logger.info(`${chalk.bold.green("Loaded")}: ${chalk.magenta(Object.keys(this.services).length)} services`);
+    this.logger.info(`${chalk3.bold.green("Loaded")}: ${chalk3.magenta(Object.keys(this.services).length)} services`);
   }
   isServiceClass(obj) {
     return typeof obj === "function" && obj.prototype instanceof MongoService && Reflect.hasMetadata(ServiceMetadataKey, obj);
   }
+  /**
+   * Register hook used by decorated services.
+   *
+   * @internal
+   */
   _register(key, instance) {
     this.services[key] = instance;
   }
 };
-function DBCatchable(errorMessage) {
+var KpgDatabaseBootstrapper = class _KpgDatabaseBootstrapper {
+  static {
+    __name(this, "KpgDatabaseBootstrapper");
+  }
+  logger;
+  static ADMIN_DB = "postgres";
+  static DATABASE_EXISTS_SQL = 'SELECT EXISTS (SELECT 1 FROM pg_database WHERE datname = $1) AS "exists"';
+  constructor(logger) {
+    this.logger = logger;
+  }
+  resolveDatabaseName(config) {
+    return _KpgDatabaseBootstrapper.parseDatabaseName(config);
+  }
+  resolveDatabaseFromPool(pool) {
+    const config = {};
+    const { options } = pool;
+    if (typeof options.database === "string") {
+      config.database = options.database;
+    }
+    if (typeof options.connectionString === "string") {
+      config.connectionString = options.connectionString;
+    }
+    return this.resolveDatabaseName(config);
+  }
+  async ensure(baseConfig) {
+    const targetDb = this.resolveDatabaseName(baseConfig);
+    if (!targetDb) {
+      this.logger.info(chalk3.gray("Skipping database existence check (no database specified)."));
+      return;
+    }
+    if (targetDb === _KpgDatabaseBootstrapper.ADMIN_DB) {
+      this.logger.info(chalk3.gray("Target database is postgres; skipping creation."));
+      return;
+    }
+    const adminConfig = this.buildAdminConfig(baseConfig);
+    if (!adminConfig) {
+      this.logger.warn(`Unable to derive admin connection when ensuring database ${targetDb}`);
+      return;
+    }
+    this.logger.info(chalk3.gray(`Ensuring database ${chalk3.yellow(targetDb)} exists...`));
+    const adminPool = new Pool(adminConfig);
+    try {
+      const exists = await this.databaseExists(adminPool, targetDb);
+      if (exists) {
+        this.logger.info(chalk3.gray(`Database ${chalk3.yellow(targetDb)} already exists.`));
+        return;
+      }
+      await this.createDatabase(adminPool, targetDb);
+      this.logger.info(chalk3.green(`Created database ${chalk3.bold(targetDb)}.`));
+    } catch (error) {
+      const err = error instanceof Error ? error : new Error(String(error));
+      this.logger.error(`Failed to ensure database ${targetDb}: ${err.message}`);
+      throw err;
+    } finally {
+      await adminPool.end();
+    }
+  }
+  buildAdminConfig(baseConfig) {
+    const adminConfig = {
+      ...baseConfig
+    };
+    const { connectionString } = adminConfig;
+    if (connectionString) {
+      const connection = _KpgDatabaseBootstrapper.applyDatabaseToConnectionString(connectionString, _KpgDatabaseBootstrapper.ADMIN_DB);
+      if (!connection) return null;
+      adminConfig.connectionString = connection;
+    }
+    adminConfig.database = _KpgDatabaseBootstrapper.ADMIN_DB;
+    return adminConfig;
+  }
+  async databaseExists(pool, database) {
+    const client = await pool.connect();
+    try {
+      const { rows } = await client.query(_KpgDatabaseBootstrapper.DATABASE_EXISTS_SQL, [
+        database
+      ]);
+      return Boolean(rows[0]?.exists);
+    } finally {
+      client.release();
+    }
+  }
+  async createDatabase(pool, database) {
+    const client = await pool.connect();
+    try {
+      const createSql = `CREATE DATABASE ${_KpgDatabaseBootstrapper.escapeIdentifier(database)}`;
+      await client.query(createSql);
+    } finally {
+      client.release();
+    }
+  }
+  static parseDatabaseName(config) {
+    if (typeof config.database === "string" && config.database.trim().length > 0) {
+      return config.database.trim();
+    }
+    const connectionString = config.connectionString;
+    if (!connectionString) return null;
+    try {
+      const url = new URL(connectionString);
+      const pathname = url.pathname.replace(/^\//, "");
+      if (!pathname) return null;
+      const [candidate] = pathname.split("/");
+      return candidate ? decodeURIComponent(candidate) : null;
+    } catch {
+      return null;
+    }
+  }
+  static applyDatabaseToConnectionString(connectionString, database) {
+    try {
+      const url = new URL(connectionString);
+      url.pathname = `/${encodeURIComponent(database)}`;
+      return url.toString();
+    } catch {
+      return null;
+    }
+  }
+  static escapeIdentifier(identifier) {
+    return `"${identifier.replace(/"/g, '""')}"`;
+  }
+};
+var KpgMigrationManager = class {
+  static {
+    __name(this, "KpgMigrationManager");
+  }
+  ctx;
+  constructor(ctx) {
+    this.ctx = ctx;
+  }
+  async migrate(options) {
+    const { target, direction = "latest", steps } = options ?? {};
+    if (typeof target !== "undefined") {
+      const label = target === NO_MIGRATIONS ? "NO_MIGRATIONS" : target;
+      await this.runMigration((migrator) => migrator.migrateTo(target), `Migrating to ${chalk3.yellow(label)}...`);
+      return;
+    }
+    switch (direction) {
+      case "latest":
+        await this.runMigration((migrator) => migrator.migrateToLatest());
+        return;
+      case "up":
+      case "down": {
+        const stepCount = steps ?? 1;
+        if (!Number.isInteger(stepCount) || stepCount < 0) {
+          throw new Error("Migration step count must be a non-negative integer");
+        }
+        if (stepCount === 0) {
+          this.logMigrationResults([]);
+          return;
+        }
+        const runner = direction === "up" ? (migrator) => migrator.migrateUp() : (migrator) => migrator.migrateDown();
+        await this.runStepwise(stepCount, direction, runner);
+        return;
+      }
+      default:
+        throw new Error(`Unknown migration direction: ${String(direction)}`);
+    }
+  }
+  async migrateUp(options) {
+    if (typeof options?.steps === "undefined") {
+      await this.migrate({
+        direction: "up"
+      });
+      return;
+    }
+    await this.migrate({
+      direction: "up",
+      steps: options.steps
+    });
+  }
+  async migrateDown(options) {
+    if (typeof options?.steps === "undefined") {
+      await this.migrate({
+        direction: "down"
+      });
+      return;
+    }
+    await this.migrate({
+      direction: "down",
+      steps: options.steps
+    });
+  }
+  async listMigrations() {
+    const migrator = await this.createMigrator();
+    return migrator.getMigrations();
+  }
+  async runMigration(runner, runningMessage = "Running migrations...") {
+    this.ctx.logger.info(chalk3.gray("Preparing migrations..."));
+    const migrator = await this.createMigrator();
+    this.ctx.logger.info(chalk3.gray(runningMessage));
+    const { error, results } = await runner(migrator);
+    this.logMigrationResults(results ?? []);
+    if (error) {
+      this.handleMigrationError(error);
+    }
+  }
+  async runStepwise(steps, direction, runner) {
+    this.ctx.logger.info(chalk3.gray("Preparing migrations..."));
+    const migrator = await this.createMigrator();
+    const directionLabel = direction === "up" ? "Running" : "Reverting";
+    const countLabel = steps === 1 ? "one migration" : `${chalk3.yellow(String(steps))} migrations`;
+    this.ctx.logger.info(chalk3.gray(`${directionLabel} ${countLabel}...`));
+    const aggregated = [];
+    let encounteredError;
+    for (let index = 0; index < steps; index += 1) {
+      const { error, results } = await runner(migrator);
+      if (results?.length) {
+        aggregated.push(...results);
+      }
+      if (error) {
+        encounteredError = error;
+        break;
+      }
+      if (!results?.length) {
+        break;
+      }
+    }
+    this.logMigrationResults(aggregated);
+    if (encounteredError) {
+      this.handleMigrationError(encounteredError);
+    }
+  }
+  async createMigrator() {
+    const provider = await this.getMigrationProvider();
+    const { config } = this.ctx;
+    return new Migrator({
+      db: this.ctx.db,
+      provider,
+      allowUnorderedMigrations: config.allowUnorderedMigrations ?? false,
+      ...keepDefined(config, "migrationTableName", "migrationLockTableName", "migrationTableSchema")
+    });
+  }
+  async getMigrationProvider() {
+    const { path: target } = this.ctx.config;
+    const resolvedTarget = Array.isArray(target) ? target.map((entry) => this.resolvePath(entry)) : this.resolvePath(target);
+    if (Array.isArray(resolvedTarget)) {
+      this.logMigrationFiles(resolvedTarget);
+      return this.createModuleProvider(resolvedTarget);
+    }
+    let migrationStat;
+    try {
+      migrationStat = await promises.stat(resolvedTarget);
+    } catch {
+      migrationStat = void 0;
+    }
+    if (migrationStat?.isDirectory()) {
+      const directory = this.relativePath(resolvedTarget);
+      this.ctx.logger.info(chalk3.gray(`Loading migrations directory ${chalk3.yellow(directory)}`));
+      return new FileMigrationProvider({
+        fs: promises,
+        path,
+        migrationFolder: resolvedTarget
+      });
+    }
+    if (migrationStat?.isFile() ?? true) {
+      this.logMigrationFiles([
+        resolvedTarget
+      ]);
+      return this.createModuleProvider([
+        resolvedTarget
+      ]);
+    }
+    const label = Array.isArray(target) ? target.join(", ") : target;
+    throw new Error(`Unable to resolve migrations at path: ${label}`);
+  }
+  async createModuleProvider(files) {
+    if (files.length === 0) {
+      throw new Error("No migration files provided");
+    }
+    const comparator = this.ctx.config.nameComparator ?? ((nameA, nameB) => nameA.localeCompare(nameB));
+    const entries = await Promise.all(files.map(async (filePath) => {
+      const moduleUrl = pathToFileURL(filePath).href;
+      const mod = await import(moduleUrl);
+      if (!this.isMigrationModule(mod)) {
+        throw new Error(`Migration file ${filePath} must export async functions up and down`);
+      }
+      const { up, down } = mod;
+      const name = path.basename(filePath);
+      const migration = {
+        async up(db) {
+          await up(db);
+        },
+        async down(db) {
+          await down(db);
+        }
+      };
+      return [
+        name,
+        migration
+      ];
+    }));
+    const sorted = entries.sort(([a], [b]) => comparator(a, b));
+    this.logPreparedMigrations(sorted);
+    return {
+      getMigrations: /* @__PURE__ */ __name(() => Promise.resolve(Object.fromEntries(sorted)), "getMigrations")
+    };
+  }
+  logMigrationFiles(files) {
+    if (!files.length) return;
+    this.ctx.logger.info("Loading migration file(s):");
+    for (const file of files) {
+      this.ctx.logger.info(`\u2192 ${chalk3.yellow(this.relativePath(file))}`);
+    }
+  }
+  logPreparedMigrations(entries) {
+    if (!entries.length) return;
+    this.ctx.logger.info("Prepared migrations:");
+    for (const [name] of entries) {
+      this.ctx.logger.info(`\u2192 ${chalk3.green(name)}`);
+    }
+  }
+  logMigrationResults(results) {
+    if (!results.length) {
+      this.ctx.logger.info(chalk3.gray("No migrations executed."));
+      return;
+    }
+    this.ctx.logger.info("Migration results:");
+    for (const result of results) {
+      if (result.status === "Success") {
+        this.ctx.logger.info(`  ${chalk3.green("\u2713")} ${chalk3.bold(result.migrationName)}`);
+        continue;
+      }
+      if (result.status === "Error") {
+        this.ctx.logger.error(`  ${chalk3.red("\u2717")} ${chalk3.bold(result.migrationName)}`);
+        continue;
+      }
+      this.ctx.logger.info(`  ${chalk3.yellow("\u2022")} ${chalk3.bold(result.migrationName)} ${chalk3.gray("(skipped)")}`);
+    }
+  }
+  relativePath(filePath) {
+    const relative = path.relative(this.ctx.baseDir, filePath);
+    return relative.startsWith("..") ? filePath : relative;
+  }
+  resolvePath(target) {
+    if (path.isAbsolute(target)) return target;
+    return path.resolve(this.ctx.baseDir, target);
+  }
+  handleMigrationError(error) {
+    const message = error instanceof Error ? error.message : inspect(error);
+    this.ctx.logger.error(`Migration failure: ${message}`);
+    if (error instanceof Error) {
+      throw error;
+    }
+    throw new Error(message);
+  }
+  isMigrationModule(value) {
+    if (!value || typeof value !== "object") return false;
+    if (!("up" in value) || !("down" in value)) return false;
+    const { up, down } = value;
+    return typeof up === "function" && typeof down === "function";
+  }
+};
+
+// src/kysely-pg/decorators/RegisterKpgService.ts
+var PgServiceMetadataKey = Symbol("db:pgServiceKey");
+var PgTableMetadataKey = Symbol("db:pgTable");
+function RegisterKpgService(key, options) {
+  return (ctor) => {
+    Reflect.defineMetadata(PgServiceMetadataKey, key, ctor);
+    const tableName = options?.table ?? String(key);
+    Reflect.defineMetadata(PgTableMetadataKey, tableName, ctor);
+  };
+}
+__name(RegisterKpgService, "RegisterKpgService");
+
+// src/kysely-pg/KpgService.ts
+var KpgService = class {
+  static {
+    __name(this, "KpgService");
+  }
+  kysely;
+  core;
+  table;
+  constructor(kysely, core) {
+    this.kysely = kysely;
+    this.core = core;
+    const ctor = this.constructor;
+    const key = Reflect.getMetadata(PgServiceMetadataKey, ctor);
+    if (!key) throw new Error(`Missing @RegisterKpgService on ${ctor.name}`);
+    const table = Reflect.getMetadata(PgTableMetadataKey, ctor);
+    if (!table) {
+      throw new Error(`Missing table metadata for ${ctor.name}. Provide a table via @RegisterKpgService().`);
+    }
+    this.table = table;
+    this.kysely._register(key, this);
+  }
+  /**
+   * Shared Kysely instance used to interact with the Postgres database.
+   */
+  get db() {
+    return this.kysely.connection;
+  }
+};
+var KpgServiceRegistry = class {
+  static {
+    __name(this, "KpgServiceRegistry");
+  }
+  plugin;
+  core;
+  logger;
+  services = /* @__PURE__ */ Object.create(null);
+  constructor(plugin, core, logger) {
+    this.plugin = plugin;
+    this.core = core;
+    this.logger = logger;
+  }
+  get map() {
+    return this.services;
+  }
+  register(key, instance) {
+    this.services[key] = instance;
+  }
+  async loadFromDirectory(dir) {
+    this.logger.info(chalk3.bold(dir));
+    await traverseDirectory(dir, (_full, rel, mod) => {
+      for (const Service of Object.values(mod)) {
+        if (this.isServiceClass(Service)) {
+          const instance = new Service(this.plugin, this.core);
+          this.logger.info(`${chalk3.italic("Registered")} ${chalk3.bold.yellow(instance.constructor.name)} from ${chalk3.gray(rel)}`);
+        }
+      }
+    }, this.logger);
+    this.logger.info(`${chalk3.bold.green("Loaded")}: ${chalk3.magenta(Object.keys(this.services).length)} services`);
+  }
+  isServiceClass(obj) {
+    return typeof obj === "function" && obj.prototype instanceof KpgService && Reflect.hasMetadata(PgServiceMetadataKey, obj);
+  }
+};
+var KyselyPg = class extends Plugin {
+  static {
+    __name(this, "KyselyPg");
+  }
+  core;
+  options;
+  logger = new Logger("KyselyPg");
+  isInitialised = false;
+  pool = null;
+  migrationManager = null;
+  serviceRegistry;
+  databaseBootstrapper;
+  databaseName = null;
+  /**
+   * Map of all services registered with the plugin, keyed by their decorator name.
+   */
+  get services() {
+    return this.serviceRegistry.map;
+  }
+  constructor(core, options) {
+    super(core), this.core = core, this.options = options;
+    this.serviceRegistry = new KpgServiceRegistry(this, core, this.logger);
+    this.databaseBootstrapper = new KpgDatabaseBootstrapper(this.logger);
+    this.core.shutdown.addTask(ShutdownPhase.ExternalResources, "stop-kyselypg", async () => await this.stop());
+  }
+  /**
+   * Connects to Postgres, runs any startup migrations, and loads decorated services.
+   *
+   * Safe to call multiple times; subsequent calls exit early.
+   */
+  async init() {
+    if (this.isInitialised) return;
+    this.isInitialised = true;
+    await this.connect();
+    const startupConfig = this.options.migrations.onStartup;
+    if (startupConfig !== false) {
+      if (startupConfig && typeof startupConfig !== "boolean") {
+        await this.migrate(startupConfig);
+      } else {
+        await this.migrate();
+      }
+    }
+    await this.serviceRegistry.loadFromDirectory(this.options.dir);
+  }
+  /**
+   * Tears down the connection pool and clears the migration manager reference.
+   */
+  async stop() {
+    await this.disconnect();
+  }
+  async connect() {
+    const pool = await this.resolvePool();
+    this.pool = pool;
+    this.registerOnConnectStatements(pool, this.options.onConnectSQL);
+    try {
+      await this.testPoolConnection(pool);
+      this.connection = new Kysely({
+        dialect: new PostgresDialect({
+          pool
+        }),
+        ...keepDefined$1(this.options.kysely ?? {})
+      });
+      this.migrationManager = new KpgMigrationManager({
+        db: this.connection,
+        logger: this.logger,
+        config: this.options.migrations,
+        baseDir: process.cwd()
+      });
+      const dbLabel = this.databaseName ?? "unknown";
+      this.logger.info(`Connected to Postgres database ${chalk3.bold.magenta(dbLabel)}`);
+    } catch (err) {
+      const error = err instanceof Error ? err : new Error(String(err));
+      this.logger.error(`Could not connect to Postgres: ${error.message}`);
+      throw error;
+    }
+  }
+  async disconnect() {
+    const pool = this.pool;
+    if (!pool) return;
+    this.pool = null;
+    this.migrationManager = null;
+    this.logger.info(chalk3.gray("Closing Postgres pool."));
+    await pool.end().catch((err) => {
+      this.logger.error(`Could not close pg pool: ${err.message}`);
+    });
+    this.logger.info(chalk3.red.bold("Disconnected from Postgres"));
+  }
+  /**
+   * Runs migrations using the supplied options or defaults to `latest`.
+   *
+   * @param options - Target migration or direction overrides
+   */
+  async migrate(options) {
+    await this.getMigrationManager().migrate(options);
+  }
+  /**
+   * Runs a single upwards migration step unless a custom count is provided.
+   *
+   * @param options - Optional configuration for step-based execution
+   */
+  async migrateUp(options) {
+    await this.getMigrationManager().migrateUp(options);
+  }
+  /**
+   * Runs a single downwards migration step unless a custom count is provided.
+   *
+   * @param options - Optional configuration for step-based execution
+   */
+  async migrateDown(options) {
+    await this.getMigrationManager().migrateDown(options);
+  }
+  /**
+   * Lists every migration the manager knows about along with its execution state.
+   */
+  listMigrations() {
+    return this.getMigrationManager().listMigrations();
+  }
+  /**
+   * Lists unapplied migrations.
+   */
+  async listPendingMigrations() {
+    const all = await this.listMigrations();
+    return all.filter((m) => !m.executedAt);
+  }
+  getMigrationManager() {
+    if (this.migrationManager) return this.migrationManager;
+    const manager = new KpgMigrationManager({
+      db: this.connection,
+      logger: this.logger,
+      config: this.options.migrations,
+      baseDir: process.cwd()
+    });
+    this.migrationManager = manager;
+    return manager;
+  }
+  /**
+   * Register hook used by decorated services.
+   *
+   * @internal
+   */
+  _register(key, instance) {
+    this.serviceRegistry.register(key, instance);
+  }
+  async resolvePool() {
+    const { pool: providedPool, connectionString } = this.options;
+    if (providedPool instanceof Pool) {
+      this.logger.info(chalk3.gray("Reusing provided Postgres pool instance."));
+      this.databaseName = this.databaseBootstrapper.resolveDatabaseFromPool(providedPool);
+      return providedPool;
+    }
+    const baseConfig = this.createPoolConfig(providedPool, connectionString);
+    await this.databaseBootstrapper.ensure(baseConfig);
+    this.databaseName = this.databaseBootstrapper.resolveDatabaseName(baseConfig);
+    this.logger.info(chalk3.gray("Creating new Postgres pool."));
+    return new Pool(baseConfig);
+  }
+  createPoolConfig(poolConfig, connectionString) {
+    const config = poolConfig ? {
+      ...poolConfig
+    } : {};
+    if (connectionString) {
+      config.connectionString = connectionString;
+    }
+    if (this.options.forceInsecureSSL) {
+      config.ssl = {
+        rejectUnauthorized: false
+      };
+    }
+    return config;
+  }
+  registerOnConnectStatements(pool, statements) {
+    if (!statements?.length) return;
+    const queuedStatements = [
+      ...statements
+    ];
+    pool.on("connect", (client) => {
+      void (async () => {
+        for (const sql of queuedStatements) {
+          await client.query(sql);
+        }
+      })();
+    });
+  }
+  async testPoolConnection(pool) {
+    const client = await pool.connect();
+    client.release();
+  }
+};
+function WrapDatabaseError(errorMessage) {
   return function(_target, _propertyKey, descriptor) {
     const originalMethod = descriptor.value;
     descriptor.value = async function(...args) {
@@ -127,8 +758,8 @@ function DBCatchable(errorMessage) {
     };
   };
 }
-__name(DBCatchable, "DBCatchable");
+__name(WrapDatabaseError, "WrapDatabaseError");
 
-export { DBCatchable, DatabaseModel, DatabaseService, ModelMetadataKey, Mongo, MongoService, ServiceMetadataKey };
+export { KpgDatabaseBootstrapper, KpgMigrationManager, KpgService, KpgServiceRegistry, KyselyPg, ModelMetadataKey, Mongo, MongoService, PgServiceMetadataKey, PgTableMetadataKey, RegisterKpgService, RegisterMongoModel, RegisterMongoService, ServiceMetadataKey, WrapDatabaseError };
 //# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map