@nmakarov/cli-toolkit 0.11.3 → 0.11.4

package/dist/index.js

@@ -2854,6 +2854,10 @@ var Db = class {
   logger;
   queriesLog = [];
   isConnected = false;
+  /**
+   * Constructor - accepts config object
+   * Use dbInit() function to initialize with Context
+   */
   constructor(config2) {
     if (!config2.connectionString) {
       throw new ParamError("Db: connectionString is required");
@@ -3140,6 +3144,91 @@ var Db = class {
     return this.isConnected && this.knexInstance !== null;
   }
 };
+function capitalizeFirstLetter(str) {
+  return str.charAt(0).toUpperCase() + str.slice(1);
+}
+async function dbConnect(context, connectionString, name, dbProfile) {
+  const defs = {
+    testDbConnection: "boolean default true",
+    name: "string",
+    poolMin: "number default 2",
+    poolMax: "number default 10",
+    acquireConnectionTimeout: "number default 10000",
+    sslRejectUnauthorized: "boolean default false"
+  };
+  const paramsConfig = context.params.getAll(defs);
+  const config2 = {
+    connectionString,
+    name: paramsConfig.name || name || "default",
+    testConnection: paramsConfig.testDbConnection,
+    profile: dbProfile ?? false,
+    pool: {
+      min: paramsConfig.poolMin,
+      max: paramsConfig.poolMax
+    },
+    acquireConnectionTimeout: paramsConfig.acquireConnectionTimeout,
+    ssl: {
+      rejectUnauthorized: paramsConfig.sslRejectUnauthorized
+    },
+    logger: context.logger
+  };
+  try {
+    const db = new Db(config2);
+    context.registerCleanup(async () => {
+      await db.disconnect();
+      context.logger.debug(`[Db] instance "${name || connectionString}" destroyed`);
+    });
+    await db.connect();
+    context.logger.debug(`[Db] instance "${name || connectionString}" initialized`);
+    return db;
+  } catch (error) {
+    if (error instanceof ParamError) {
+      throw error;
+    }
+    const errorMsg = error instanceof Error ? error.message : String(error);
+    throw new ParamError(`[Db] connect error: ${errorMsg}`);
+  }
+}
+async function dbFindAndConnect(context, dbNameOrConnectionString) {
+  let dbName;
+  let dbConnectionString;
+  let dbProfile;
+  if (dbNameOrConnectionString) {
+    if (dbNameOrConnectionString.match(/^(postgresql|mysql):\/\/[^\s]+:[^\s]+@[^\s]+:\d+\/[^\s]+$/)) {
+      dbName = void 0;
+      dbConnectionString = dbNameOrConnectionString;
+    } else {
+      dbName = dbNameOrConnectionString;
+    }
+  } else {
+    const defs = {
+      dbName: "string",
+      dbConnectionString: "string",
+      dbProfile: "boolean default false"
+    };
+    const paramsConfig = context.params.getAll(defs);
+    dbName = paramsConfig.dbName;
+    dbConnectionString = paramsConfig.dbConnectionString;
+    dbProfile = paramsConfig.dbProfile;
+  }
+  if (!dbName && !dbConnectionString) {
+    throw new ParamError("Db: either dbName or dbConnectionString must be specified");
+  }
+  if (dbName) {
+    const paramName = `dbConnectionString${capitalizeFirstLetter(dbName)}`;
+    dbConnectionString = await context.params.get(paramName, "string");
+    if (!dbConnectionString) {
+      throw new ParamError(
+        `Db: cannot find dbConnectionString for dbName="${dbName}" (looked for param "${paramName}")`
+      );
+    }
+  }
+  const db = await dbConnect(context, dbConnectionString, dbName, dbProfile);
+  return db;
+}
+async function dbInit(context, dbNameOrConnectionString) {
+  return await dbFindAndConnect(context, dbNameOrConnectionString);
+}
 
 // src/logger/index.ts
 import chalk from "chalk";
@@ -3534,6 +3623,9 @@ export {
   buildBreadcrumb,
   buildDetailBreadcrumb,
   buildFooter,
+  dbConnect,
+  dbFindAndConnect,
+  dbInit,
   defaultFileSynopsisFunction,
   defaultVersionSynopsisFunction,
   fileDatabaseInit,