@xcr1234/dbhub-fork 1.0.0 → 1.1.0

package/dist/sqlite-SJAXGYH3.js

@@ -0,0 +1,321 @@
+import {
+  quoteIdentifier
+} from "./chunk-JFWX35TB.js";
+import {
+  SQLRowLimiter
+} from "./chunk-BRXZ5ZQB.js";
+import {
+  ConnectorRegistry,
+  SafeURL,
+  obfuscateDSNPassword,
+  splitSQLStatements
+} from "./chunk-C7WEAPX4.js";
+
+// src/connectors/sqlite/index.ts
+import fs from "fs/promises";
+import initSqlJs from "sql.js";
+var SQLiteDSNParser = class {
+  async parse(dsn, config) {
+    if (!this.isValidDSN(dsn)) {
+      const obfuscatedDSN = obfuscateDSNPassword(dsn);
+      const expectedFormat = this.getSampleDSN();
+      throw new Error(
+        `Invalid SQLite DSN format.
+Provided: ${obfuscatedDSN}
+Expected: ${expectedFormat}`
+      );
+    }
+    try {
+      const url = new SafeURL(dsn);
+      let dbPath;
+      if (url.hostname === "" && url.pathname === "/:memory:") {
+        dbPath = ":memory:";
+      } else {
+        if (url.pathname.startsWith("//")) {
+          dbPath = url.pathname.substring(2);
+        } else if (url.pathname.match(/^\/[A-Za-z]:\//)) {
+          dbPath = url.pathname.substring(1);
+        } else {
+          dbPath = url.pathname;
+        }
+      }
+      return { dbPath };
+    } catch (error) {
+      throw new Error(
+        `Failed to parse SQLite DSN: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+  getSampleDSN() {
+    return "sqlite:///path/to/database.db";
+  }
+  isValidDSN(dsn) {
+    try {
+      return dsn.startsWith("sqlite://");
+    } catch (error) {
+      return false;
+    }
+  }
+};
+var SQLiteConnector = class _SQLiteConnector {
+  constructor() {
+    this.id = "sqlite";
+    this.name = "SQLite";
+    this.dsnParser = new SQLiteDSNParser();
+    this.db = null;
+    this.dbPath = ":memory:";
+    this.SQL = null;
+    this.sourceId = "default";
+  }
+  getId() {
+    return this.sourceId;
+  }
+  clone() {
+    return new _SQLiteConnector();
+  }
+  // Helper method to save in-memory database to disk
+  async saveToDisk() {
+    if (this.dbPath !== ":memory:" && this.db) {
+      const data = this.db.export();
+      const buffer = Buffer.from(data);
+      await fs.writeFile(this.dbPath, buffer);
+    }
+  }
+  // Wrapper equivalent to sqlite3 db.all()
+  async dbAll(sql, params = []) {
+    if (!this.db) throw new Error("Not connected to SQLite database");
+    const stmt = this.db.prepare(sql);
+    try {
+      if (params && params.length > 0) {
+        stmt.bind(params);
+      }
+      const rows = [];
+      while (stmt.step()) {
+        rows.push(stmt.getAsObject());
+      }
+      return rows;
+    } finally {
+      stmt.free();
+    }
+  }
+  // Wrapper equivalent to sqlite3 db.get()
+  async dbGet(sql, params = []) {
+    const rows = await this.dbAll(sql, params);
+    return rows.length > 0 ? rows[0] : void 0;
+  }
+  // Wrapper equivalent to sqlite3 db.run()
+  async dbRun(sql, params = []) {
+    if (!this.db) throw new Error("Not connected to SQLite database");
+    this.db.run(sql, params);
+    return { changes: this.db.getRowsModified() };
+  }
+  async connect(dsn, initScript, config) {
+    const parsedConfig = await this.dsnParser.parse(dsn, config);
+    this.dbPath = parsedConfig.dbPath;
+    try {
+      if (!this.SQL) {
+        this.SQL = await initSqlJs();
+      }
+      if (this.dbPath === ":memory:") {
+        this.db = new this.SQL.Database();
+      } else {
+        try {
+          const fileBuffer = await fs.readFile(this.dbPath);
+          this.db = new this.SQL.Database(fileBuffer);
+        } catch (err) {
+          if (err.code === "ENOENT") {
+            if (config?.readonly) {
+              throw new Error(`Database file not found in readonly mode: ${this.dbPath}`);
+            }
+            this.db = new this.SQL.Database();
+            await this.saveToDisk();
+          } else {
+            throw err;
+          }
+        }
+      }
+      if (initScript) {
+        this.db.run(initScript);
+        await this.saveToDisk();
+      }
+    } catch (error) {
+      console.error("Failed to connect to SQLite database (sql.js):", error);
+      throw error;
+    }
+  }
+  async disconnect() {
+    if (this.db) {
+      try {
+        await this.saveToDisk();
+        this.db.close();
+        this.db = null;
+      } catch (error) {
+        console.error("Error during SQLite disconnect:", error);
+        this.db = null;
+      }
+    }
+    return Promise.resolve();
+  }
+  async getSchemas() {
+    if (!this.db) throw new Error("Not connected to SQLite database");
+    return ["main"];
+  }
+  async getTables(schema) {
+    try {
+      const rows = await this.dbAll(`
+        SELECT name FROM sqlite_master 
+        WHERE type='table' AND name NOT LIKE 'sqlite_%'
+        ORDER BY name
+      `);
+      return rows.map((row) => row.name);
+    } catch (error) {
+      throw error;
+    }
+  }
+  async tableExists(tableName, schema) {
+    try {
+      const row = await this.dbGet(`
+        SELECT name FROM sqlite_master 
+        WHERE type='table' AND name = ?
+      `, [tableName]);
+      return !!row;
+    } catch (error) {
+      throw error;
+    }
+  }
+  async getTableIndexes(tableName, schema) {
+    try {
+      const indexInfoRows = await this.dbAll(`
+        SELECT name as index_name, 0 as is_unique
+        FROM sqlite_master 
+        WHERE type = 'index' AND tbl_name = ?
+      `, [tableName]);
+      const quotedTableName = quoteIdentifier(tableName, "sqlite");
+      const indexListRows = await this.dbAll(
+        `PRAGMA index_list(${quotedTableName})`
+      );
+      const indexUniqueMap = /* @__PURE__ */ new Map();
+      for (const indexListRow of indexListRows) {
+        indexUniqueMap.set(indexListRow.name, indexListRow.unique === 1);
+      }
+      const tableInfo = await this.dbAll(
+        `PRAGMA table_info(${quotedTableName})`
+      );
+      const pkColumns = tableInfo.filter((col) => col.pk > 0).map((col) => col.name);
+      const results = [];
+      for (const indexInfo of indexInfoRows) {
+        const quotedIndexName = quoteIdentifier(indexInfo.index_name, "sqlite");
+        const indexDetailRows = await this.dbAll(
+          `PRAGMA index_info(${quotedIndexName})`
+        );
+        const columnNames = indexDetailRows.map((row) => row.name);
+        results.push({
+          index_name: indexInfo.index_name,
+          column_names: columnNames,
+          is_unique: indexUniqueMap.get(indexInfo.index_name) || false,
+          is_primary: false
+        });
+      }
+      if (pkColumns.length > 0) {
+        results.push({
+          index_name: "PRIMARY",
+          column_names: pkColumns,
+          is_unique: true,
+          is_primary: true
+        });
+      }
+      return results;
+    } catch (error) {
+      throw error;
+    }
+  }
+  async getTableSchema(tableName, schema) {
+    try {
+      const quotedTableName = quoteIdentifier(tableName, "sqlite");
+      const rows = await this.dbAll(`PRAGMA table_info(${quotedTableName})`);
+      return rows.map((row) => ({
+        column_name: row.name,
+        data_type: row.type,
+        is_nullable: row.notnull === 1 || row.pk > 0 ? "NO" : "YES",
+        column_default: row.dflt_value,
+        description: null
+      }));
+    } catch (error) {
+      throw error;
+    }
+  }
+  async getStoredProcedures(schema, routineType) {
+    if (!this.db) throw new Error("Not connected to SQLite database");
+    return [];
+  }
+  async getStoredProcedureDetail(procedureName, schema) {
+    throw new Error(
+      "SQLite does not support stored procedures. Functions are defined programmatically through the SQLite API, not stored in the database."
+    );
+  }
+  async executeSQL(sql, options, parameters) {
+    if (!this.db) throw new Error("Not connected to SQLite database");
+    try {
+      const statements = splitSQLStatements(sql, "sqlite");
+      let dataModified = false;
+      if (statements.length === 1) {
+        let processedStatement = statements[0];
+        const trimmedStatement = statements[0].toLowerCase().trim();
+        const isReadStatement = trimmedStatement.startsWith("select") || trimmedStatement.startsWith("with") || trimmedStatement.startsWith("explain") || trimmedStatement.startsWith("analyze") || trimmedStatement.startsWith("pragma") && (trimmedStatement.includes("table_info") || trimmedStatement.includes("index_info") || trimmedStatement.includes("index_list") || trimmedStatement.includes("foreign_key_list"));
+        if (options.maxRows) {
+          processedStatement = SQLRowLimiter.applyMaxRows(processedStatement, options.maxRows);
+        }
+        if (isReadStatement) {
+          try {
+            const params = parameters || [];
+            const rows = await this.dbAll(processedStatement, params);
+            return { rows, rowCount: rows.length };
+          } catch (error) {
+            console.error(`[SQLite executeSQL] ERROR: ${error.message}`);
+            throw error;
+          }
+        } else {
+          try {
+            const params = parameters || [];
+            const result = await this.dbRun(processedStatement, params);
+            await this.saveToDisk();
+            return { rows: [], rowCount: result.changes ?? 0 };
+          } catch (error) {
+            console.error(`[SQLite executeSQL] ERROR: ${error.message}`);
+            throw error;
+          }
+        }
+      } else {
+        if (parameters && parameters.length > 0) {
+          throw new Error("Parameters are not supported for multi-statement queries in SQLite");
+        }
+        let totalChanges = 0;
+        let allRows = [];
+        for (let statement of statements) {
+          const trimmedStatement = statement.toLowerCase().trim();
+          const isReadStatement = trimmedStatement.startsWith("select") || trimmedStatement.startsWith("with") || trimmedStatement.startsWith("explain") || trimmedStatement.startsWith("analyze") || trimmedStatement.startsWith("pragma") && (trimmedStatement.includes("table_info") || trimmedStatement.includes("index_info") || trimmedStatement.includes("index_list") || trimmedStatement.includes("foreign_key_list"));
+          if (isReadStatement) {
+            statement = SQLRowLimiter.applyMaxRows(statement, options.maxRows);
+            const rows = await this.dbAll(statement);
+            allRows.push(...rows);
+          } else {
+            const result = await this.dbRun(statement);
+            totalChanges += result.changes ?? 0;
+            dataModified = true;
+          }
+        }
+        if (dataModified) {
+          await this.saveToDisk();
+        }
+        return { rows: allRows, rowCount: totalChanges + allRows.length };
+      }
+    } catch (error) {
+      throw error;
+    }
+  }
+};
+var sqliteConnector = new SQLiteConnector();
+ConnectorRegistry.register(sqliteConnector);
+export {
+  SQLiteConnector
+};

package/dist/{sqlserver-5RM44GWI.js → sqlserver-YV3KVJ3B.js}

@@ -9,7 +9,6 @@ import {
   SafeURL,
   obfuscateDSNPassword
 } from "./chunk-C7WEAPX4.js";
-import "./chunk-FAIJPBT5.js";
 
 // src/connectors/sqlserver/index.ts
 import sql from "mssql";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xcr1234/dbhub-fork",
-  "version": "1.0.0",
+  "version": "1.1.0",
   "mcpName": "io.github.xcr1234/dbhub",
   "description": "Minimal, token-efficient Database MCP Server for PostgreSQL, MySQL, SQL Server, SQLite, MariaDB",
   "repository": {

package/dist/chunk-FAIJPBT5.js

@@ -1,40 +0,0 @@
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
-  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
-}) : x)(function(x) {
-  if (typeof require !== "undefined") return require.apply(this, arguments);
-  throw Error('Dynamic require of "' + x + '" is not supported');
-});
-var __commonJS = (cb, mod) => function __require2() {
-  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
-
-export {
-  __require,
-  __commonJS,
-  __toESM,
-  __publicField
-};