@nmakarov/cli-toolkit 0.23.0 → 0.25.0

package/dist/cli-runner.js

@@ -2049,6 +2049,18 @@ var Params = class _Params {
       this._currentModule = prev;
     }
   }
+  /**
+   * Async variant of {@link runWithModule} for modules that await params.get().
+   */
+  async runWithModuleAsync(moduleName, fn) {
+    const prev = this._currentModule;
+    this._currentModule = moduleName;
+    try {
+      return await fn();
+    } finally {
+      this._currentModule = prev;
+    }
+  }
   /**
    * Infer module name from call stack: first caller outside params/index gives path like .../src/<moduleName>/...
    */
@@ -2577,38 +2589,71 @@ var KNEX_DEFAULTS = {
 };
 var Db = class {
   static async init(context, options = {}) {
-    const defs2 = {
-      dbName: "string",
-      dbConnectionString: "string",
-      dbProfile: "boolean default false"
-    };
-    const discovered = context?.params?.getAllForModule?.("db", defs2) ?? {};
-    const merged = { ...discovered, ...options };
-    let { dbName, dbConnectionString } = merged;
-    const { dbProfile } = merged;
-    if (!dbName && !dbConnectionString) {
-      dbName = "local";
-    }
-    if (dbName && /^(postgresql|mysql):\/\//.test(dbName)) {
-      dbConnectionString = dbName;
-      dbName = void 0;
-    }
-    if (dbName && !dbConnectionString) {
-      const paramName = `dbConnectionString${capitalizeFirstLetter(dbName)}`;
-      dbConnectionString = await context.params.get(paramName, "string");
+    const buildConfig = async () => {
+      const defs2 = {
+        dbName: "string",
+        dbProfile: "boolean default false"
+      };
+      const discovered = context?.params?.getAllForModule?.("db", defs2) ?? {};
+      const merged = { ...discovered, ...options };
+      let { dbName, dbProfile } = merged;
+      let dbConnectionString = options.dbConnectionString ?? options.connectionString;
+      let connectionParam = dbConnectionString ? "options" : null;
       if (!dbConnectionString) {
-        throw new ParamError(
-          `Db: cannot find dbConnectionString for dbName="${dbName}" (looked for param "${paramName}")`
-        );
+        const src = context?.args?.getSource?.("dbConnectionString");
+        if (src === "cli" || src === "overrides" || src === "config") {
+          dbConnectionString = await context.params.get("dbConnectionString", "string");
+          connectionParam = "dbConnectionString";
+        }
       }
-    }
-    const config2 = {
-      ...KNEX_DEFAULTS,
-      connectionString: dbConnectionString,
-      name: dbName || merged.name || "default",
-      profile: !!dbProfile,
-      logger: context.logger
+      if (!dbConnectionString && dbName && /^(postgresql|mysql):\/\//.test(dbName)) {
+        dbConnectionString = dbName;
+        dbName = void 0;
+      }
+      if (!dbConnectionString && dbName) {
+        const paramName = `dbConnectionString${capitalizeFirstLetter(dbName)}`;
+        dbConnectionString = await context.params.get(paramName, "string");
+        connectionParam = paramName;
+        if (!dbConnectionString) {
+          throw new ParamError(
+            `Db: cannot find dbConnectionString for dbName="${dbName}" (looked for param "${paramName}")`
+          );
+        }
+      }
+      if (!dbConnectionString) {
+        dbConnectionString = await context.params.get("dbConnectionString", "string");
+        if (dbConnectionString) {
+          connectionParam = "dbConnectionString";
+        }
+      }
+      if (!dbConnectionString) {
+        if (!dbName) {
+          dbName = "local";
+        }
+        const paramName = `dbConnectionString${capitalizeFirstLetter(dbName)}`;
+        dbConnectionString = await context.params.get(paramName, "string");
+        connectionParam = paramName;
+        if (!dbConnectionString) {
+          throw new ParamError(
+            `Db: cannot find dbConnectionString for dbName="${dbName}" (looked for param "${paramName}")`
+          );
+        }
+      }
+      const displayName = resolveDbDisplayName(
+        dbName,
+        connectionParam,
+        context?.args?.env,
+        merged.name
+      );
+      return {
+        ...KNEX_DEFAULTS,
+        connectionString: dbConnectionString,
+        name: displayName,
+        profile: !!dbProfile,
+        logger: context.logger
+      };
     };
+    const config2 = context?.params?.runWithModuleAsync ? await context.params.runWithModuleAsync("db", buildConfig) : await buildConfig();
     return dbConnect(context, config2);
   }
   constructor(config2) {
@@ -2625,7 +2670,6 @@ var Db = class {
       acquireConnectionTimeout: 1e4,
       ssl: { rejectUnauthorized: false },
       logger: console,
-      name: "default",
       ...config2
     };
     this.logger = this.config.logger;
@@ -2725,9 +2769,7 @@ var Db = class {
         await this.testConnection();
       }
       this.isConnected = true;
-      this.logger.debug?.(
-        `[Db] Connected to database "${this.config.name || this.config.connectionString}"`
-      );
+      this.logger.debug?.(formatDbConnectMessage(this.config.name, this.config.connectionString));
     } catch (error) {
       if (error instanceof ParamError) {
         throw error;
@@ -2745,9 +2787,7 @@ var Db = class {
       this.knexInstance = null;
       this.isConnected = false;
       this.queriesLog = [];
-      this.logger.debug?.(
-        `[Db] Disconnected from database "${this.config.name || this.config.connectionString}"`
-      );
+      this.logger.debug?.(formatDbDisconnectMessage(this.config.name, this.config.connectionString));
     } catch (error) {
       const errorMsg = this.getErrorMessage(error);
       this.logger.error?.(`[Db] Error disconnecting: ${errorMsg}`);
@@ -2876,15 +2916,74 @@ var Db = class {
 function capitalizeFirstLetter(str) {
   return str.charAt(0).toUpperCase() + str.slice(1);
 }
+function resolveDbDisplayName(dbName, connectionParam, argsEnv, mergedName) {
+  if (dbName) {
+    return dbName;
+  }
+  if (mergedName) {
+    return mergedName;
+  }
+  if (connectionParam?.startsWith("dbConnectionString") && connectionParam.length > "dbConnectionString".length) {
+    return connectionParam.slice("dbConnectionString".length).toLowerCase();
+  }
+  if (connectionParam === "dbConnectionString" && argsEnv) {
+    return argsEnv;
+  }
+  return void 0;
+}
+function formatDbConnectMessage(name, connectionString) {
+  const endpointSuffix = formatConnectionEndpointSuffix(connectionString);
+  if (name) {
+    return `[Db] Connected to database "${name}"${endpointSuffix}`;
+  }
+  return `[Db] Connected${endpointSuffix}`;
+}
+function formatDbDisconnectMessage(name, connectionString) {
+  const endpointSuffix = formatConnectionEndpointSuffix(connectionString);
+  if (name) {
+    return `[Db] Disconnected from database "${name}"${endpointSuffix}`;
+  }
+  return `[Db] Disconnected${endpointSuffix}`;
+}
+function formatDbInstanceMessage(action, name) {
+  if (name) {
+    return `[Db] instance "${name}" ${action}`;
+  }
+  return `[Db] instance ${action}`;
+}
+function formatConnectionEndpointSuffix(connectionString) {
+  const endpoint = formatConnectionEndpoint(connectionString);
+  return endpoint ? ` (${endpoint})` : "";
+}
+function formatConnectionEndpoint(connectionString) {
+  try {
+    const url = new URL(connectionString);
+    const host = url.hostname;
+    if (!host) {
+      return null;
+    }
+    let port = url.port;
+    if (!port) {
+      if (url.protocol === "postgresql:") {
+        port = "5432";
+      } else if (url.protocol === "mysql:") {
+        port = "3306";
+      }
+    }
+    return port ? `${host}:${port}` : host;
+  } catch {
+    return null;
+  }
+}
 async function dbConnect(context, config2) {
   try {
     const db = new Db(config2);
     context.registerCleanup(async () => {
       await db.disconnect();
-      context.logger.debug?.(`[Db] instance "${config2.name}" disconnected`);
+      context.logger.debug?.(formatDbInstanceMessage("disconnected", config2.name));
     });
     await db.connect();
-    context.logger.debug?.(`[Db] instance "${config2.name}" initialized`);
+    context.logger.debug?.(formatDbInstanceMessage("initialized", config2.name));
     return db;
   } catch (error) {
     if (error instanceof ParamError) {