db-mcp 1.0.2 → 1.1.0

package/dist/index.js

@@ -1,17 +1,5 @@
-/**
- * db-mcp - SQLite MCP Server
- *
- * Main entry point and public API exports.
- */
-// Core server
-export { DbMcpServer, createServer, DEFAULT_CONFIG, } from "./server/McpServer.js";
-// Error classes
-export { DbMcpError, ConnectionError, QueryError, AuthenticationError, AuthorizationError, ValidationError, } from "./types/index.js";
-// Base adapter class
-export { DatabaseAdapter } from "./adapters/DatabaseAdapter.js";
-// Tool filtering utilities
-export { TOOL_GROUPS, META_GROUPS, ALL_TOOL_GROUPS, parseToolFilter, isToolEnabled, filterTools, getToolFilterFromEnv, getFilterSummary, } from "./filtering/ToolFilter.js";
-// Version info
-export const VERSION = "0.1.0";
-export const NAME = "db-mcp";
-//# sourceMappingURL=index.js.map
+export { DEFAULT_CONFIG, DbMcpServer, NAME, VERSION, createServer } from './chunk-DZQLDEQS.js';
+export { DatabaseAdapter } from './chunk-Z2GFQU3G.js';
+import './chunk-S5IDDSSB.js';
+export { AuthenticationError, AuthorizationError, ConnectionError, QueryError, ValidationError } from './chunk-4IA3DB5C.js';
+export { ALL_TOOL_GROUPS, DbMcpError, META_GROUPS, TOOL_GROUPS, filterTools, getFilterSummary, getToolFilterFromEnv, isToolEnabled, parseToolFilter } from './chunk-AOUL5SHS.js';

package/dist/sqlite-VHBA4ABV.js

@@ -0,0 +1,600 @@
+import { getCoreTools, getJsonHelperTools, getJsonOperationTools, getTextTools, getStatsTools, getVirtualTools, getVectorTools, getGeoTools, getAdminTools, getIntrospectionTools, getMigrationTools, getCodeModeTools, isDDL, getResourceDefinitions, getPromptDefinitions, applyCommonPragmas, autoEnableWal, detectAndSetJsonbSupport, SchemaManager, normalizeSqliteParams } from './chunk-DWJXQEFA.js';
+export { getCoreTools } from './chunk-DWJXQEFA.js';
+import { DatabaseAdapter } from './chunk-Z2GFQU3G.js';
+import { getToolGroupIcon } from './chunk-S5IDDSSB.js';
+import { ConnectionError, ConfigurationError, QueryError } from './chunk-4IA3DB5C.js';
+import { createModuleLogger, ERROR_CODES, DbMcpError } from './chunk-AOUL5SHS.js';
+import initSqlJs from 'sql.js';
+
+// src/adapters/sqlite/tools/index.ts
+function getAllToolDefinitions(adapter) {
+  const tools = [
+    ...getCoreTools(adapter),
+    ...getJsonHelperTools(adapter),
+    ...getJsonOperationTools(adapter),
+    ...getTextTools(adapter),
+    ...getStatsTools(adapter),
+    ...getVirtualTools(adapter),
+    ...getVectorTools(adapter),
+    ...getGeoTools(adapter),
+    ...getAdminTools(adapter),
+    ...getIntrospectionTools(adapter),
+    ...getMigrationTools(adapter),
+    ...getCodeModeTools(adapter)
+  ];
+  for (const tool of tools) {
+    if (!tool.icons) {
+      const icons = getToolGroupIcon(tool.group);
+      if (icons) {
+        tool.icons = icons;
+      }
+    }
+  }
+  return tools;
+}
+function getToolsByGroup(adapter, group) {
+  return getAllToolDefinitions(adapter).filter((tool) => tool.group === group);
+}
+
+// src/adapters/sqlite/query-executor.ts
+var log = createModuleLogger("SQLITE");
+function rowsFromSqlJsResult(result) {
+  const numColumns = result.columns.length;
+  const numRows = result.values.length;
+  const rows = new Array(numRows);
+  const cols = result.columns;
+  for (let i = 0; i < numRows; i++) {
+    const rowObj = {};
+    const rowValues = result.values[i];
+    if (rowValues) {
+      for (let j = 0; j < numColumns; j++) {
+        rowObj[cols[j]] = rowValues[j];
+      }
+    }
+    rows[i] = rowObj;
+  }
+  return rows;
+}
+function executeRead(db, sql, params) {
+  const start = Date.now();
+  try {
+    const normalizedParams = normalizeSqliteParams(params);
+    const results = normalizedParams ? db.exec(sql, normalizedParams) : db.exec(sql);
+    if (results.length === 0) {
+      return Promise.resolve({
+        rows: [],
+        executionTimeMs: Date.now() - start
+      });
+    }
+    const firstResult = results[0];
+    if (!firstResult) {
+      return Promise.resolve({
+        rows: [],
+        executionTimeMs: Date.now() - start
+      });
+    }
+    const columns = firstResult.columns.map((name) => ({
+      name,
+      type: "unknown"
+    }));
+    const rows = rowsFromSqlJsResult(firstResult);
+    return Promise.resolve({
+      rows,
+      columns,
+      executionTimeMs: Date.now() - start
+    });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    log.error(`Query failed: ${message}`, {
+      code: ERROR_CODES.DB.QUERY_FAILED.full
+    });
+    throw new QueryError(
+      `Query execution failed: ${message}`,
+      "DB_QUERY_FAILED",
+      {
+        sql,
+        cause: error instanceof Error ? error : void 0
+      }
+    );
+  }
+}
+function executeWrite(db, sql, params) {
+  const start = Date.now();
+  try {
+    const normalizedParams = normalizeSqliteParams(params);
+    if (normalizedParams) {
+      db.run(sql, normalizedParams);
+    } else {
+      db.run(sql);
+    }
+    const changes = db.getRowsModified();
+    return Promise.resolve({
+      rowsAffected: changes,
+      executionTimeMs: Date.now() - start
+    });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    log.error(`Write query failed: ${message}`, {
+      code: ERROR_CODES.DB.QUERY_FAILED.full
+    });
+    throw new QueryError(`Write query failed: ${message}`, "DB_WRITE_FAILED", {
+      sql,
+      cause: error instanceof Error ? error : void 0
+    });
+  }
+}
+function executeGeneral(db, sql, params) {
+  const start = Date.now();
+  try {
+    const normalizedParams = normalizeSqliteParams(params);
+    const results = normalizedParams ? db.exec(sql, normalizedParams) : db.exec(sql);
+    if (results.length === 0) {
+      return Promise.resolve({
+        rowsAffected: db.getRowsModified(),
+        executionTimeMs: Date.now() - start
+      });
+    }
+    const firstResult = results[0];
+    if (!firstResult) {
+      return Promise.resolve({
+        rowsAffected: db.getRowsModified(),
+        executionTimeMs: Date.now() - start
+      });
+    }
+    const rows = rowsFromSqlJsResult(firstResult);
+    return Promise.resolve({
+      rows,
+      executionTimeMs: Date.now() - start
+    });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    log.error(`Query failed: ${message}`, {
+      code: ERROR_CODES.DB.QUERY_FAILED.full
+    });
+    throw new QueryError(`Query failed: ${message}`, "DB_QUERY_FAILED", {
+      sql,
+      cause: error instanceof Error ? error : void 0
+    });
+  }
+}
+var log2 = createModuleLogger("SQLITE");
+async function connectSqliteDatabase(adapter, config) {
+  if (config.type !== "sqlite") {
+    throw new ConfigurationError(
+      `Invalid database type: expected 'sqlite', got '${config.type}'`,
+      "DB_TYPE_MISMATCH"
+    );
+  }
+  const sqliteConfig = config;
+  try {
+    const sqlJsInstance = await initSqlJs();
+    const filePath = sqliteConfig.filePath ?? sqliteConfig.connectionString ?? ":memory:";
+    let db;
+    if (filePath === ":memory:") {
+      db = new sqlJsInstance.Database();
+      log2.info("Connected to in-memory SQLite database", {
+        code: "SQLITE_CONNECT"
+      });
+    } else {
+      try {
+        const fs = await import('fs');
+        if (fs.existsSync(filePath)) {
+          const buffer = await fs.promises.readFile(filePath);
+          db = new sqlJsInstance.Database(buffer);
+          log2.info(`Connected to SQLite database: ${filePath}`, {
+            code: "SQLITE_CONNECT"
+          });
+        } else {
+          db = new sqlJsInstance.Database();
+          log2.info(`Created new SQLite database: ${filePath}`, {
+            code: "SQLITE_CONNECT"
+          });
+        }
+      } catch {
+        db = new sqlJsInstance.Database();
+        log2.warning("File access unavailable, using in-memory database", {
+          code: "SQLITE_FALLBACK"
+        });
+      }
+    }
+    if (sqliteConfig.options) {
+      applyCommonPragmas(
+        { runPragma: (pragma) => db.run(`PRAGMA ${pragma}`) },
+        sqliteConfig.options
+      );
+    }
+    autoEnableWal(
+      { runPragma: (pragma) => db.run(`PRAGMA ${pragma}`) },
+      filePath,
+      sqliteConfig.options,
+      log2
+    );
+    detectAndSetJsonbSupport(() => {
+      const versionResult = db.exec("SELECT sqlite_version()");
+      return versionResult[0]?.values[0]?.[0] ?? "0.0.0";
+    }, log2);
+    const schemaManager = new SchemaManager(adapter);
+    return { db, sqlJsInstance, schemaManager };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    log2.error(`Failed to connect to SQLite: ${message}`, {
+      code: ERROR_CODES.DB.CONNECT_FAILED.full
+    });
+    throw new ConnectionError(
+      `SQLite connection failed: ${message}`,
+      "DB_CONNECT_FAILED",
+      {
+        cause: error instanceof Error ? error : void 0
+      }
+    );
+  }
+}
+async function disconnectSqliteDatabase(db, config) {
+  if (config?.filePath && config.filePath !== ":memory:") {
+    try {
+      const fs = await import('fs');
+      const data = db.export();
+      await fs.promises.writeFile(config.filePath, Buffer.from(data));
+      log2.info(`Saved database to: ${config.filePath}`, {
+        code: "SQLITE_DISCONNECT"
+      });
+    } catch {
+      log2.warning("Could not save database to file", {
+        code: "SQLITE_SAVE_FAILED"
+      });
+    }
+  }
+  db.close();
+  log2.info("Disconnected from SQLite database", {
+    code: "SQLITE_DISCONNECT"
+  });
+}
+
+// src/adapters/sqlite/sqlite-adapter/schema.ts
+async function fallBackGetSchema(adapter) {
+  const tables = await adapter.listTables();
+  const indexes = await adapter.getIndexes();
+  return { tables, indexes };
+}
+async function fallBackListTables(adapter) {
+  const result = await adapter.executeReadQuery(
+    `SELECT name, type FROM sqlite_master
+           WHERE type IN ('table', 'view') AND name NOT LIKE 'sqlite_%'
+           ORDER BY name`
+  );
+  const tables = [];
+  for (const row of result.rows ?? []) {
+    const name = row["name"];
+    const type = row["type"];
+    const tableInfo = await adapter.describeTable(name);
+    tables.push({ ...tableInfo, type });
+  }
+  return tables;
+}
+async function fallBackDescribeTable(adapter, tableName) {
+  if (!/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(tableName)) {
+    throw new DbMcpError(
+      "Invalid table name",
+      "SQLITE_INVALID_TABLE",
+      "validation" /* VALIDATION */
+    );
+  }
+  const result = await adapter.executeReadQuery(
+    `PRAGMA table_info("${tableName}")`
+  );
+  const columns = (result.rows ?? []).map((row) => ({
+    name: row["name"],
+    type: row["type"],
+    nullable: row["notnull"] === 0,
+    primaryKey: row["pk"] === 1,
+    defaultValue: row["dflt_value"]
+  }));
+  const countResult = await adapter.executeReadQuery(
+    `SELECT COUNT(*) as count FROM "${tableName}"`
+  );
+  const rowCount = countResult.rows?.[0]?.["count"] ?? 0;
+  return {
+    name: tableName,
+    type: "table",
+    columns,
+    rowCount
+  };
+}
+async function fallBackGetIndexes(adapter, table) {
+  let sql = `SELECT name, tbl_name, sql FROM sqlite_master
+           WHERE type = 'index' AND sql IS NOT NULL`;
+  let params;
+  if (table) {
+    sql += ` AND tbl_name = ?`;
+    params = [table];
+  }
+  const result = await adapter.executeReadQuery(sql, params);
+  const indexes = [];
+  for (const row of result.rows ?? []) {
+    const indexName = row["name"];
+    const tableName = row["tbl_name"];
+    const sqlDef = row["sql"];
+    let columns;
+    try {
+      const indexInfo = await adapter.executeReadQuery(
+        `PRAGMA index_info("${indexName}")`
+      );
+      columns = (indexInfo.rows ?? []).map((col) => col["name"]);
+    } catch {
+      columns = [];
+    }
+    indexes.push({
+      name: indexName,
+      tableName,
+      columns,
+      unique: sqlDef?.toUpperCase().includes("UNIQUE") ?? false
+    });
+  }
+  return indexes;
+}
+
+// src/adapters/sqlite/sqlite-adapter.ts
+var SqliteAdapter = class extends DatabaseAdapter {
+  type = "sqlite";
+  name = "SQLite Adapter";
+  version = "1.1.0";
+  // Keep in sync with package.json
+  /**
+   * Check if this adapter uses native (better-sqlite3) backend.
+   * Returns false for WASM/sql.js adapter.
+   */
+  isNativeBackend() {
+    return false;
+  }
+  /**
+   * Get the configured database file path.
+   * Returns the user-configured path, not internal WASM virtual filesystem paths.
+   */
+  getConfiguredPath() {
+    return this.config?.filePath ?? this.config?.connectionString ?? ":memory:";
+  }
+  db = null;
+  config = null;
+  schemaManager = null;
+  /**
+   * Connect to a SQLite database
+   */
+  async connect(config) {
+    this.config = config;
+    const { db, schemaManager } = await connectSqliteDatabase(this, config);
+    this.db = db;
+    this.schemaManager = schemaManager;
+    this.connected = true;
+  }
+  /**
+   * Disconnect from the database
+   */
+  async disconnect() {
+    if (this.db) {
+      await disconnectSqliteDatabase(this.db, this.config);
+      this.db = null;
+      this.connected = false;
+    }
+  }
+  /**
+   * Get database health status
+   */
+  getHealth() {
+    if (!this.db) {
+      return Promise.resolve({ connected: false, error: "Not connected" });
+    }
+    try {
+      const start = Date.now();
+      const result = this.db.exec("SELECT sqlite_version() as version");
+      const latencyMs = Date.now() - start;
+      const version = result[0]?.values[0]?.[0] ?? "unknown";
+      return Promise.resolve({
+        connected: true,
+        latencyMs,
+        version,
+        details: {
+          filePath: this.config?.filePath ?? this.config?.connectionString ?? ":memory:",
+          walMode: this.config?.options?.walMode ?? false
+        }
+      });
+    } catch (error) {
+      return Promise.resolve({
+        connected: false,
+        error: error instanceof Error ? error.message : String(error)
+      });
+    }
+  }
+  /**
+   * Execute a read-only query
+   */
+  executeReadQuery(sql, params) {
+    this.ensureConnected();
+    this.validateQuery(sql, true);
+    return executeRead(this.ensureDb(), sql, params);
+  }
+  /**
+   * Execute a write query
+   */
+  async executeWriteQuery(sql, params, skipValidation = false) {
+    this.ensureConnected();
+    if (!skipValidation) {
+      this.validateQuery(sql, false);
+    }
+    const result = await executeWrite(this.ensureDb(), sql, params);
+    if (isDDL(sql)) {
+      this.clearSchemaCache();
+    }
+    return result;
+  }
+  /**
+   * Execute any query (for admin operations)
+   */
+  async executeQuery(sql, params) {
+    this.ensureConnected();
+    const result = await executeGeneral(this.ensureDb(), sql, params);
+    if (isDDL(sql)) {
+      this.clearSchemaCache();
+    }
+    return result;
+  }
+  /**
+   * Get full database schema (cached via SchemaManager)
+   */
+  async getSchema() {
+    this.ensureConnected();
+    if (this.schemaManager) {
+      return this.schemaManager.getSchema();
+    }
+    return fallBackGetSchema(this);
+  }
+  /**
+   * List all tables (cached via SchemaManager)
+   */
+  async listTables() {
+    this.ensureConnected();
+    if (this.schemaManager) {
+      return this.schemaManager.listTables();
+    }
+    return fallBackListTables(this);
+  }
+  /**
+   * Describe a table's structure (cached via SchemaManager)
+   */
+  async describeTable(tableName) {
+    this.ensureConnected();
+    if (this.schemaManager) {
+      return this.schemaManager.describeTable(tableName);
+    }
+    return fallBackDescribeTable(this, tableName);
+  }
+  /**
+   * List available schemas (SQLite has only 'main')
+   */
+  listSchemas() {
+    return Promise.resolve(["main"]);
+  }
+  /**
+   * Get indexes, optionally for a specific table (cached via SchemaManager)
+   */
+  async getIndexes(table) {
+    this.ensureConnected();
+    if (this.schemaManager) {
+      if (table) {
+        return this.schemaManager.getTableIndexes(table);
+      }
+      return this.schemaManager.getAllIndexes();
+    }
+    return fallBackGetIndexes(this, table);
+  }
+  /**
+   * Get all indexes in a single query (cached via SchemaManager)
+   * Performance optimization: eliminates N+1 query pattern
+   */
+  async getAllIndexes() {
+    return this.getIndexes();
+  }
+  /**
+   * Clear the schema metadata cache
+   * Call after DDL operations or when fresh data is needed
+   */
+  clearSchemaCache() {
+    if (this.schemaManager) {
+      this.schemaManager.clearCache();
+    }
+  }
+  /**
+   * Get adapter capabilities
+   */
+  getCapabilities() {
+    return {
+      json: true,
+      fullTextSearch: false,
+      // FTS5 not available in WASM/sql.js build
+      vector: true,
+      // Custom implementation
+      geospatial: false,
+      // SpatiaLite not bundled
+      transactions: true,
+      preparedStatements: true,
+      connectionPooling: false
+      // sql.js is single-connection
+    };
+  }
+  /**
+   * Get supported tool groups
+   */
+  getSupportedToolGroups() {
+    return [
+      "core",
+      "json",
+      "text",
+      "stats",
+      "vector",
+      "admin",
+      "geo",
+      "introspection",
+      "migration"
+    ];
+  }
+  /**
+   * Get all tool definitions
+   */
+  getToolDefinitions() {
+    return getAllToolDefinitions(this);
+  }
+  /**
+   * Get resource definitions
+   */
+  getResourceDefinitions() {
+    return getResourceDefinitions(this);
+  }
+  /**
+   * Get prompt definitions
+   */
+  getPromptDefinitions() {
+    return getPromptDefinitions(this);
+  }
+  /**
+   * Ensure database is connected
+   */
+  ensureConnected() {
+    super.ensureConnected();
+    if (!this.db) {
+      throw new ConnectionError(
+        "Not connected to database",
+        "DB_NOT_CONNECTED"
+      );
+    }
+  }
+  /**
+   * Ensure database is connected and return the database instance
+   */
+  ensureDb() {
+    this.ensureConnected();
+    const db = this.db;
+    if (!db) {
+      throw new ConnectionError(
+        "Not connected to database",
+        "DB_NOT_CONNECTED"
+      );
+    }
+    return db;
+  }
+  /**
+   * Get the raw database instance (for tools)
+   */
+  getDatabase() {
+    return this.ensureDb();
+  }
+  /**
+   * Execute raw SQL and return results (for tools)
+   */
+  rawQuery(sql, params) {
+    return this.executeQuery(sql, params);
+  }
+};
+function createSqliteAdapter() {
+  return new SqliteAdapter();
+}
+
+export { SqliteAdapter, createSqliteAdapter, getAllToolDefinitions, getToolsByGroup };