@nmakarov/cli-toolkit 0.3.0 → 0.4.0

package/dist/index.js

@@ -2601,8 +2601,304 @@ var FileDatabase = class {
     return { ...this.metadata };
   }
 };
+
+// src/db/index.ts
+import knex from "knex";
+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 = knex({
+        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;
+  }
+};
 export {
   Args,
+  Db,
   Divider,
   FileDatabase,
   FileDatabaseError,