@nmakarov/cli-toolkit 0.3.0 → 0.5.0

package/dist/index.cjs

@@ -31,6 +31,7 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var src_exports = {};
 __export(src_exports, {
   Args: () => Args,
+  Db: () => Db,
   Divider: () => Divider,
   FileDatabase: () => FileDatabase,
   FileDatabaseError: () => FileDatabaseError,
@@ -59,6 +60,7 @@ __export(src_exports, {
   joiEdateType: () => joiEdateType,
   joiStringArrayType: () => joiStringArrayType,
   organizeFooterMessages: () => organizeFooterMessages,
+  setupContext: () => setupContext,
   showListScreen: () => showListScreen,
   showMenuScreen: () => showMenuScreen,
   showMultiColumnListScreen: () => showMultiColumnListScreen,
@@ -2664,9 +2666,587 @@ var FileDatabase = class {
     return { ...this.metadata };
   }
 };
+
+// src/db/index.ts
+var import_knex = __toESM(require("knex"), 1);
+var Db = class {
+  knexInstance = null;
+  config;
+  logger;
+  queriesLog = [];
+  isConnected = false;
+  constructor(config2) {
+    if (!config2.connectionString) {
+      throw new ParamError("Db: connectionString is required");
+    }
+    this.config = {
+      testConnection: true,
+      profile: false,
+      pool: { min: 2, max: 10 },
+      acquireConnectionTimeout: 1e4,
+      ssl: { rejectUnauthorized: false },
+      logger: console,
+      name: "default",
+      ...config2
+    };
+    this.logger = this.config.logger;
+    const instance2 = this;
+    const callableWrapper = function(...args) {
+      throw new Error("This should never be called directly");
+    };
+    callableWrapper._instance = instance2;
+    return new Proxy(callableWrapper, {
+      // Intercept function calls: db('table')
+      apply: (target, thisArg, argumentsList) => {
+        const inst = target._instance;
+        if (!inst.knexInstance) {
+          throw new Error("Db: Not connected. Call connect() first.");
+        }
+        return inst.knexInstance(...argumentsList);
+      },
+      // Intercept property access: db.schema, db.raw, etc.
+      get: (target, prop) => {
+        if (prop === "_instance") {
+          return target._instance;
+        }
+        const instance3 = target._instance;
+        const ownMethods = [
+          "connect",
+          "disconnect",
+          "testConnection",
+          "tableExists",
+          "getQueryLog",
+          "getKnex",
+          "isConnectedToDb",
+          "getErrorMessage",
+          "detectClient",
+          "attachProfiler"
+        ];
+        if (prop in instance3) {
+          const value = instance3[prop];
+          if (typeof value === "function" && ownMethods.includes(prop)) {
+            return value.bind(instance3);
+          }
+          if (typeof value !== "function") {
+            return value;
+          }
+        }
+        if (instance3.knexInstance) {
+          const knexProp = instance3.knexInstance[prop];
+          if (typeof knexProp === "function") {
+            return knexProp.bind(instance3.knexInstance);
+          }
+          return knexProp;
+        }
+        if (prop in instance3) {
+          const method = instance3[prop];
+          if (typeof method === "function") {
+            return method.bind(instance3);
+          }
+          return method;
+        }
+        return void 0;
+      }
+    });
+  }
+  /**
+   * Detect database client type from connection string
+   */
+  detectClient(connectionString) {
+    if (connectionString.match(/^postgresql/)) {
+      return "pg";
+    }
+    if (connectionString.match(/^mysql/)) {
+      return "mysql2";
+    }
+    return null;
+  }
+  /**
+   * Connect to the database
+   */
+  async connect() {
+    if (this.isConnected && this.knexInstance) {
+      this.logger.warn?.("[Db] Already connected");
+      return;
+    }
+    const client = this.detectClient(this.config.connectionString);
+    if (!client) {
+      throw new ParamError(
+        `Db: Cannot determine client type from connection string. Expected postgresql:// or mysql://`
+      );
+    }
+    try {
+      const connectionConfig = {
+        connectionString: this.config.connectionString,
+        family: 4
+        // Force IPv4 only (disable IPv6)
+      };
+      this.knexInstance = (0, import_knex.default)({
+        client,
+        connection: connectionConfig,
+        pool: this.config.pool,
+        acquireConnectionTimeout: this.config.acquireConnectionTimeout,
+        ...this.config.ssl && { ssl: this.config.ssl }
+      });
+      if (this.config.profile) {
+        this.attachProfiler();
+      }
+      if (this.config.testConnection) {
+        await this.testConnection();
+      }
+      this.isConnected = true;
+      this.logger.debug?.(`[Db] Connected to database "${this.config.name || this.config.connectionString}"`);
+    } catch (error) {
+      if (error instanceof ParamError) {
+        throw error;
+      }
+      const errorMsg = this.getErrorMessage(error);
+      throw new ParamError(`Db: Connection failed - ${errorMsg}`);
+    }
+  }
+  /**
+   * Disconnect from the database
+   */
+  async disconnect() {
+    if (!this.knexInstance) {
+      return;
+    }
+    try {
+      await this.knexInstance.destroy();
+      this.knexInstance = null;
+      this.isConnected = false;
+      this.queriesLog = [];
+      this.logger.debug?.(`[Db] Disconnected from database "${this.config.name || this.config.connectionString}"`);
+    } catch (error) {
+      const errorMsg = this.getErrorMessage(error);
+      this.logger.error?.(`[Db] Error disconnecting: ${errorMsg}`);
+      throw error;
+    }
+  }
+  /**
+   * Extract error message from various error types
+   */
+  getErrorMessage(error) {
+    if (error instanceof AggregateError) {
+      const errors = error.errors || [];
+      if (errors.length > 0) {
+        const firstError = errors[0];
+        const firstErrorMsg = firstError instanceof Error ? firstError.message : String(firstError);
+        const allSimilar = errors.every((e) => {
+          const msg = e instanceof Error ? e.message : String(e);
+          const codeMatch = msg.match(/^(\w+)\s/);
+          const firstCodeMatch = firstErrorMsg.match(/^(\w+)\s/);
+          return codeMatch && firstCodeMatch && codeMatch[1] === firstCodeMatch[1];
+        });
+        if (allSimilar && errors.length > 1) {
+          const addresses = errors.map((e) => {
+            const msg = e instanceof Error ? e.message : String(e);
+            const addrMatch = msg.match(/([:\d.]+:\d+)/);
+            return addrMatch ? addrMatch[1] : null;
+          }).filter(Boolean);
+          if (addresses.length > 0) {
+            const codeMatch = firstErrorMsg.match(/^(\w+)\s/);
+            const code = codeMatch ? codeMatch[1] : "Connection error";
+            return `${code} (tried: ${addresses.join(", ")})`;
+          }
+        }
+        const uniqueMessages = [...new Set(errors.map((e) => {
+          return e instanceof Error ? e.message : String(e);
+        }))];
+        if (uniqueMessages.length === 1) {
+          return uniqueMessages[0];
+        }
+        return uniqueMessages.join("; ");
+      }
+      return error.message || "Multiple errors occurred";
+    }
+    if (error instanceof Error) {
+      const errorWithCode = error;
+      if (errorWithCode.code) {
+        return `${errorWithCode.code}: ${error.message || String(error)}`;
+      }
+      return error.message || String(error);
+    }
+    if (typeof error === "string") {
+      return error;
+    }
+    if (error?.message) {
+      const msg = String(error.message);
+      const errorWithCode = error;
+      if (errorWithCode.code) {
+        return `${errorWithCode.code}: ${msg}`;
+      }
+      return msg;
+    }
+    return String(error) || "Unknown error";
+  }
+  /**
+   * Test database connection
+   */
+  async testConnection() {
+    if (!this.knexInstance) {
+      throw new Error("Db: Not connected. Call connect() first.");
+    }
+    try {
+      const result = await this.knexInstance.raw("SELECT 2+3 AS result");
+      const isOk = result.rows?.[0]?.result === 5 || result[0]?.[0]?.result === 5;
+      this.logger.debug?.(`[Db] Connection test: ${isOk ? "OK" : "FAILED"}`);
+      return isOk;
+    } catch (error) {
+      const errorMsg = this.getErrorMessage(error);
+      this.logger.error?.(`[Db] Connection test failed: ${errorMsg}`);
+      throw new ParamError(`Db: Connection test failed - ${errorMsg}`);
+    }
+  }
+  /**
+   * Attach query profiler to log all queries
+   */
+  attachProfiler() {
+    if (!this.knexInstance) {
+      return;
+    }
+    this.queriesLog = [];
+    this.knexInstance.queriesLog = this.queriesLog;
+    this.knexInstance.on("query", (query) => {
+      query.__startTime = process.hrtime();
+    });
+    this.knexInstance.on("query-response", (response, query) => {
+      const [seconds, nanoseconds] = process.hrtime(query.__startTime);
+      const executionTimeMs = (seconds * 1e3 + nanoseconds / 1e6).toFixed(2);
+      const logEntry = {
+        sql: query.sql,
+        bindings: query.bindings || [],
+        executionTimeMs
+      };
+      this.queriesLog.push(logEntry);
+      this.logger.debug?.(`[Db] Query: ${query.sql} | Duration: ${executionTimeMs}ms`);
+    });
+    this.knexInstance.on("query-error", (error, query) => {
+      this.logger.error?.(`[Db] Query failed: ${query.sql}`, error);
+    });
+  }
+  /**
+   * Get query log (only available if profiling is enabled)
+   */
+  getQueryLog() {
+    return [...this.queriesLog];
+  }
+  /**
+   * Check if a table exists
+   */
+  async tableExists(tableName) {
+    if (!this.knexInstance) {
+      throw new Error("Db: Not connected. Call connect() first.");
+    }
+    try {
+      return await this.knexInstance.schema.hasTable(tableName);
+    } catch (error) {
+      this.logger.error?.(`[Db] Error checking table existence: ${error.message}`);
+      throw error;
+    }
+  }
+  /**
+   * Get the underlying Knex instance (for advanced usage)
+   */
+  getKnex() {
+    if (!this.knexInstance) {
+      throw new Error("Db: Not connected. Call connect() first.");
+    }
+    return this.knexInstance;
+  }
+  /**
+   * Get connection status
+   */
+  isConnectedToDb() {
+    return this.isConnected && this.knexInstance !== null;
+  }
+};
+
+// src/logger/index.ts
+var import_chalk = __toESM(require("chalk"), 1);
+var import_util = __toESM(require("util"), 1);
+
+// src/logger/transports.ts
+var ConsoleTransport = class {
+  write(payload) {
+    console.info(payload);
+  }
+};
+var ParentProcessTransport = class {
+  write(payload) {
+    if (process.env.VITEST || process.env.NODE_ENV === "test") {
+      console.info(payload);
+      return;
+    }
+    if (typeof process.send === "function" && process.connected === true) {
+      process.send(payload);
+    } else {
+      console.info(payload);
+    }
+  }
+};
+
+// src/logger/index.ts
+var ALL_LEVELS = [
+  "silly",
+  "debug",
+  "logic",
+  "info",
+  "notice",
+  "warn",
+  "error",
+  "results",
+  "request",
+  "response",
+  "progress"
+];
+var LEVEL_COLORS = {
+  error: import_chalk.default.red.bold,
+  warn: import_chalk.default.rgb(255, 165, 0),
+  notice: import_chalk.default.cyan,
+  info: import_chalk.default.white.bold,
+  logic: import_chalk.default.gray,
+  debug: import_chalk.default.gray,
+  silly: import_chalk.default.gray,
+  request: import_chalk.default.green,
+  response: import_chalk.default.yellow,
+  progress: import_chalk.default.green,
+  results: import_chalk.default.magenta
+};
+var CliToolkitLogger = class {
+  options;
+  transport;
+  startTimes = {};
+  lastProgressTimes = {};
+  constructor(options = {}) {
+    this.options = this.normalizeOptions(options);
+    this.transport = this.options.route === "ipc" ? new ParentProcessTransport() : new ConsoleTransport();
+  }
+  setMode(mode) {
+    if (!this.isValidMode(mode)) {
+      throw new Error(`Unsupported logger mode: ${mode}`);
+    }
+    this.options.mode = mode;
+  }
+  debug(message, ...chunks) {
+    this.out({ level: "debug", message, chunks });
+  }
+  info(message, ...chunks) {
+    this.out({ level: "info", message, chunks });
+  }
+  notice(message, ...chunks) {
+    this.out({ level: "notice", message, chunks });
+  }
+  warn(message, ...chunks) {
+    this.out({ level: "warn", message, chunks });
+  }
+  error(message, ...chunks) {
+    this.out({ level: "error", message, chunks });
+  }
+  logic(message, ...chunks) {
+    this.out({ level: "logic", message, chunks });
+  }
+  silly(message, ...chunks) {
+    this.out({ level: "silly", message, chunks });
+  }
+  results(results) {
+    this.out({ level: "results", message: "results", results });
+  }
+  request(operation, ...chunks) {
+    const message = this.inspectChunks([operation, ...chunks]);
+    this.out({ level: "request", message });
+  }
+  response(operation, ...chunks) {
+    const message = this.inspectChunks([operation, ...chunks]);
+    this.out({ level: "response", message });
+  }
+  progress(message, opts) {
+    const { prefix, count, total } = opts;
+    const paddedTotal = String(total).length;
+    const paddedCount = String(count).padStart(paddedTotal, " ");
+    const payload = {
+      level: "progress",
+      message,
+      count: paddedCount,
+      total,
+      prefix
+    };
+    if (!this.startTimes[prefix ?? ""]) {
+      this.startTimes[prefix ?? ""] = Date.now();
+    }
+    if (this.options.progressTimes) {
+      const elapsedSeconds = (Date.now() - this.startTimes[prefix ?? ""]) / 1e3;
+      let remaining = -1;
+      if (count > 1) {
+        const rate = elapsedSeconds / (count - 1);
+        remaining = (total - count) * rate;
+      }
+      payload.elapsed = this.round(elapsedSeconds, 2);
+      payload.remaining = remaining >= 0 ? this.round(remaining, 2) : remaining;
+    }
+    if (count >= total) {
+      delete this.startTimes[prefix ?? ""];
+      delete this.lastProgressTimes[prefix ?? ""];
+    }
+    if (this.shouldOutputProgress(prefix ?? "", count, total)) {
+      this.out(payload);
+      if (this.options.progressThrottle && prefix) {
+        this.lastProgressTimes[prefix] = Date.now();
+      }
+    }
+  }
+  shouldOutputProgress(prefix, count, total) {
+    if (!this.options.progressThrottle) {
+      return true;
+    }
+    if (count === 1 || count === total || !prefix) {
+      return true;
+    }
+    const lastTime = this.lastProgressTimes[prefix];
+    if (!lastTime) {
+      return true;
+    }
+    return Date.now() - lastTime >= this.options.progressThrottle;
+  }
+  out(struct) {
+    if (this.options.silent) {
+      return;
+    }
+    if (!this.options.levels.includes(struct.level)) {
+      return;
+    }
+    if (this.options.prefix && !struct.prefix) {
+      struct.prefix = this.options.prefix;
+    }
+    const output = this.options.mode === "json" ? struct : this.formatLog(struct);
+    this.transport.write(output);
+  }
+  formatLog(struct) {
+    const parts = [];
+    const now = /* @__PURE__ */ new Date();
+    if (this.options.timestamp) {
+      parts.push(now.toISOString());
+    }
+    if (this.options.showLevel) {
+      parts.push(struct.level.toUpperCase());
+    }
+    if (struct.level === "progress") {
+      if (struct.prefix) {
+        parts.push(LEVEL_COLORS[struct.level].bold(struct.prefix));
+      }
+      if (struct.count !== void 0 && struct.total !== void 0) {
+        parts.push(LEVEL_COLORS[struct.level](`${struct.count}/${struct.total}`));
+      }
+    } else if (struct.prefix) {
+      parts.push(import_chalk.default.cyan(`[${struct.prefix}]`));
+    }
+    if (struct.message) {
+      const formatter = LEVEL_COLORS[struct.level] ?? import_chalk.default.white;
+      parts.push(formatter.bold(struct.message));
+    }
+    if (struct.level === "progress") {
+      if (struct.elapsed !== void 0 && struct.remaining !== void 0) {
+        const formatter = LEVEL_COLORS[struct.level];
+        parts.push(formatter(`${struct.elapsed}/${struct.remaining}`));
+      }
+    }
+    if (struct.chunks && struct.chunks.length) {
+      parts.push(this.inspectChunks(struct.chunks));
+    }
+    if (struct.results) {
+      const formatter = LEVEL_COLORS[struct.level] ?? import_chalk.default.white;
+      parts.push(formatter(JSON.stringify(struct.results, null, 4)));
+    }
+    return parts.join(" ");
+  }
+  inspectChunks(chunks) {
+    return chunks.map((chunk) => import_util.default.inspect(chunk, { colors: true, depth: null })).join(" ");
+  }
+  normalizeOptions(options) {
+    const { route, mode, prefix, silent, showLevel, timestamp, levels, progress } = options;
+    const shouldUseIpc = this.shouldUseIpcRoute();
+    const normalized = {
+      mode: this.isValidMode(mode) ? mode : "text",
+      route: route ?? (shouldUseIpc ? "ipc" : "console"),
+      prefix,
+      silent: silent ?? false,
+      showLevel: showLevel ?? true,
+      timestamp: timestamp ?? false,
+      levels: this.normalizeLevels(levels),
+      progressTimes: progress?.withTimes ?? false,
+      progressThrottle: progress?.throttleMs
+    };
+    return normalized;
+  }
+  shouldUseIpcRoute() {
+    if (process.env.VITEST || process.env.NODE_ENV === "test") {
+      return false;
+    }
+    return typeof process.send === "function" && process.connected === true;
+  }
+  normalizeLevels(levels) {
+    if (!levels || !levels.length) {
+      return ALL_LEVELS;
+    }
+    const includes = levels.filter((level) => !level.startsWith("-"));
+    const excludes = levels.filter((level) => level.startsWith("-")).map((level) => level.slice(1));
+    const unknown = [...includes, ...excludes].filter((level) => !ALL_LEVELS.includes(level));
+    if (unknown.length) {
+      console.warn(`[Logger] Unknown level(s): ${unknown.join(", ")}`);
+    }
+    const base = includes.length ? includes : ALL_LEVELS;
+    return base.filter((level) => !excludes.includes(level));
+  }
+  isValidMode(mode) {
+    return mode === void 0 || mode === null || mode === "text" || mode === "json";
+  }
+  round(value, places) {
+    const factor = Math.pow(10, places);
+    return Math.round(value * factor) / factor;
+  }
+};
+
+// src/init/index.ts
+var import_events = require("events");
+function setup(opts = {}) {
+  const args = new Args({
+    overrides: opts.overrides || {},
+    defaults: opts.defaults || {}
+  });
+  const params = new Params({ args }, opts.overrides || {});
+  const loggerOptions = opts.logger || {};
+  const logger = new CliToolkitLogger({
+    mode: loggerOptions.mode || "text",
+    route: loggerOptions.route || "console",
+    prefix: loggerOptions.prefix,
+    silent: loggerOptions.silent,
+    showLevel: loggerOptions.showLevel,
+    timestamp: loggerOptions.timestamp,
+    levels: loggerOptions.levels
+  });
+  const cleanupFunctions = [];
+  const context = {
+    args,
+    params,
+    logger,
+    emitter: new import_events.EventEmitter(),
+    isStop: () => false,
+    // Will be set in init function
+    cleanupFunctions,
+    registerCleanup: (fn) => {
+      cleanupFunctions.push(fn);
+    }
+  };
+  logger.debug("[setup] completed successfully");
+  return context;
+}
+function setupContext(opts = {}) {
+  return setup(opts);
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   Args,
+  Db,
   Divider,
   FileDatabase,
   FileDatabaseError,
@@ -2695,6 +3275,7 @@ var FileDatabase = class {
   joiEdateType,
   joiStringArrayType,
   organizeFooterMessages,
+  setupContext,
   showListScreen,
   showMenuScreen,
   showMultiColumnListScreen,