db-mcp 1.0.2 → 1.1.0

package/dist/chunk-S5IDDSSB.js

@@ -0,0 +1,74 @@
+// src/utils/icons.ts
+var MDI_BASE = "https://cdn.jsdelivr.net/npm/@mdi/svg@7.4.47/svg";
+var SERVER_ICONS = [
+  {
+    src: `${MDI_BASE}/server.svg`,
+    mimeType: "image/svg+xml"
+  }
+];
+var TOOL_GROUP_ICONS = {
+  core: [{ src: `${MDI_BASE}/database.svg`, mimeType: "image/svg+xml" }],
+  json: [{ src: `${MDI_BASE}/code-json.svg`, mimeType: "image/svg+xml" }],
+  text: [{ src: `${MDI_BASE}/format-text.svg`, mimeType: "image/svg+xml" }],
+  stats: [{ src: `${MDI_BASE}/chart-bar.svg`, mimeType: "image/svg+xml" }],
+  vector: [
+    { src: `${MDI_BASE}/vector-polyline.svg`, mimeType: "image/svg+xml" }
+  ],
+  admin: [{ src: `${MDI_BASE}/cog.svg`, mimeType: "image/svg+xml" }],
+  geo: [{ src: `${MDI_BASE}/earth.svg`, mimeType: "image/svg+xml" }],
+  introspection: [
+    { src: `${MDI_BASE}/graph-outline.svg`, mimeType: "image/svg+xml" }
+  ],
+  migration: [
+    { src: `${MDI_BASE}/source-branch.svg`, mimeType: "image/svg+xml" }
+  ],
+  codemode: [{ src: `${MDI_BASE}/code-braces.svg`, mimeType: "image/svg+xml" }]
+};
+function getToolGroupIcon(group) {
+  return TOOL_GROUP_ICONS[group];
+}
+
+// src/utils/annotations.ts
+var READ_ONLY = {
+  readOnlyHint: true,
+  destructiveHint: false,
+  openWorldHint: false
+};
+var WRITE = {
+  readOnlyHint: false,
+  destructiveHint: false,
+  openWorldHint: false
+};
+var DESTRUCTIVE = {
+  readOnlyHint: false,
+  destructiveHint: true,
+  openWorldHint: false
+};
+var IDEMPOTENT = {
+  readOnlyHint: false,
+  destructiveHint: false,
+  idempotentHint: true,
+  openWorldHint: false
+};
+var ADMIN = {
+  readOnlyHint: false,
+  destructiveHint: false,
+  openWorldHint: false
+};
+function readOnly(title) {
+  return { title, ...READ_ONLY };
+}
+function write(title) {
+  return { title, ...WRITE };
+}
+function destructive(title) {
+  return { title, ...DESTRUCTIVE };
+}
+function idempotent(title) {
+  return { title, ...IDEMPOTENT };
+}
+function admin(title) {
+  return { title, ...ADMIN };
+}
+
+export { READ_ONLY, SERVER_ICONS, admin, destructive, getToolGroupIcon, idempotent, readOnly, write };

package/dist/chunk-Z2GFQU3G.js

@@ -0,0 +1,363 @@
+import { ConnectionError, formatHandlerError, ValidationError } from './chunk-4IA3DB5C.js';
+import { isToolEnabled } from './chunk-AOUL5SHS.js';
+import { ResourceTemplate } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { z } from 'zod';
+
+// src/adapters/query-validation.ts
+var DANGEROUS_SQL_PATTERNS = [
+  /;\s*DROP\s+/i,
+  /;\s*DELETE\s+/i,
+  /;\s*TRUNCATE\s+/i,
+  /;\s*ALTER\s+/i,
+  /;\s*UNION\s+ALL\s+SELECT/i,
+  /;\s*UNION\s+SELECT/i,
+  /;\s*ATTACH\s+/i,
+  /;\s*DETACH\s+/i
+];
+var COMMENT_SQL_PATTERNS = [/--.*$/m, /\/\*[\s\S]*?\*\//];
+function stripSqlStringLiterals(sql) {
+  return sql.replace(/'(?:''|[^'])*'/g, "''");
+}
+var WRITE_PREFIXES = [
+  "INSERT",
+  "UPDATE",
+  "DELETE",
+  "DROP",
+  "CREATE",
+  "ALTER",
+  "TRUNCATE"
+];
+function validateQuery(sql, isReadOnly) {
+  const trimmedSql = sql.trim().toUpperCase();
+  if (isReadOnly) {
+    for (const prefix of WRITE_PREFIXES) {
+      if (trimmedSql.startsWith(prefix)) {
+        throw new ValidationError(
+          `Read-only mode: ${prefix} statements are not allowed`,
+          "DB_READ_ONLY_VIOLATION"
+        );
+      }
+    }
+  }
+  for (const pattern of DANGEROUS_SQL_PATTERNS) {
+    if (pattern.test(sql)) {
+      throw new ValidationError(
+        "Query contains potentially dangerous patterns",
+        "DB_DANGEROUS_PATTERN"
+      );
+    }
+  }
+  const sqlWithoutStrings = stripSqlStringLiterals(sql);
+  for (const pattern of COMMENT_SQL_PATTERNS) {
+    if (pattern.test(sqlWithoutStrings)) {
+      throw new ValidationError(
+        "Query contains potentially dangerous patterns",
+        "DB_DANGEROUS_PATTERN"
+      );
+    }
+  }
+}
+
+// src/adapters/registration/tools.ts
+function registerToolImpl(adapter, server, tool) {
+  const toolOptions = {
+    description: tool.description
+  };
+  if (tool.inputSchema !== void 0) {
+    const schema = tool.inputSchema;
+    if (typeof schema === "object" && schema !== null && "partial" in schema && typeof schema.partial === "function") {
+      toolOptions["inputSchema"] = schema.partial().passthrough();
+    } else {
+      toolOptions["inputSchema"] = schema;
+    }
+  }
+  if (tool.outputSchema !== void 0) {
+    toolOptions["outputSchema"] = tool.outputSchema;
+  }
+  if (tool.annotations) {
+    toolOptions["annotations"] = tool.annotations;
+  }
+  if (tool.icons) {
+    toolOptions["icons"] = tool.icons;
+  }
+  const hasOutputSchema = Boolean(tool.outputSchema);
+  server.registerTool(
+    tool.name,
+    toolOptions,
+    async (args, extra) => {
+      try {
+        const extraMeta = extra;
+        const progressToken = extraMeta?._meta?.progressToken;
+        const context = adapter.createContext(
+          void 0,
+          server.server,
+          progressToken
+        );
+        const result = await tool.handler(args, context);
+        if (hasOutputSchema) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: JSON.stringify(result)
+              }
+            ],
+            structuredContent: result
+          };
+        }
+        return {
+          content: [
+            {
+              type: "text",
+              text: typeof result === "string" ? result : JSON.stringify(result)
+            }
+          ]
+        };
+      } catch (error) {
+        const structured = formatHandlerError(error);
+        if (hasOutputSchema) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: JSON.stringify(structured, null, 2)
+              }
+            ],
+            structuredContent: structured,
+            isError: true
+          };
+        }
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(structured, null, 2)
+            }
+          ],
+          isError: true
+        };
+      }
+    }
+  );
+}
+function registerResourceImpl(adapter, server, resource) {
+  const isTemplate = /\{[^}]+\}/.test(resource.uri);
+  if (isTemplate) {
+    const template = new ResourceTemplate(resource.uri, { list: void 0 });
+    server.registerResource(
+      resource.name,
+      template,
+      {
+        mimeType: resource.mimeType ?? "application/json",
+        description: resource.description,
+        ...resource.icons ? { icons: resource.icons } : {}
+      },
+      async (resourceUri, _variables) => {
+        const context = adapter.createContext();
+        const content = await resource.handler(resourceUri.toString(), context);
+        return {
+          contents: [
+            {
+              uri: resourceUri.toString(),
+              mimeType: resource.mimeType ?? "application/json",
+              text: typeof content === "string" ? content : JSON.stringify(content, null, 2)
+            }
+          ]
+        };
+      }
+    );
+  } else {
+    server.registerResource(
+      resource.name,
+      resource.uri,
+      {
+        mimeType: resource.mimeType ?? "application/json",
+        description: resource.description,
+        ...resource.icons ? { icons: resource.icons } : {}
+      },
+      async (resourceUri) => {
+        const context = adapter.createContext();
+        const content = await resource.handler(resourceUri.toString(), context);
+        return {
+          contents: [
+            {
+              uri: resourceUri.toString(),
+              mimeType: resource.mimeType ?? "application/json",
+              text: typeof content === "string" ? content : JSON.stringify(content, null, 2)
+            }
+          ]
+        };
+      }
+    );
+  }
+}
+function buildArgsSchema(args) {
+  if (!args || args.length === 0) return void 0;
+  const hasRequired = args.some((a) => a.required === true);
+  if (!hasRequired) return void 0;
+  const schema = {};
+  for (const arg of args) {
+    const field = z.string().describe(arg.description);
+    schema[arg.name] = arg.required ? field : field.optional();
+  }
+  return schema;
+}
+function registerPromptImpl(adapter, server, prompt) {
+  const argsSchema = buildArgsSchema(prompt.arguments);
+  const iconOpts = prompt.icons ? { icons: prompt.icons } : {};
+  const handleResult = async (args) => {
+    const context = adapter.createContext();
+    const safeArgs = args ?? {};
+    const result = await prompt.handler(safeArgs, context);
+    const messages = Array.isArray(result) ? result : [
+      {
+        role: "assistant",
+        content: {
+          type: "text",
+          text: typeof result === "string" ? result : JSON.stringify(result)
+        }
+      }
+    ];
+    return { messages };
+  };
+  if (argsSchema) {
+    server.registerPrompt(
+      prompt.name,
+      { description: prompt.description, argsSchema, ...iconOpts },
+      async (args) => handleResult(args)
+    );
+  } else {
+    server.registerPrompt(
+      prompt.name,
+      { description: prompt.description, ...iconOpts },
+      async (args) => handleResult(args)
+    );
+  }
+}
+
+// src/adapters/database-adapter.ts
+var DatabaseAdapter = class {
+  /** Connection status */
+  connected = false;
+  /** Database configuration */
+  config = null;
+  /**
+   * Check if connected to the database
+   */
+  isConnected() {
+    return this.connected;
+  }
+  /**
+   * Register tools with the MCP server
+   * @param server - MCP server instance
+   * @param filterConfig - Tool filter configuration
+   */
+  registerTools(server, filterConfig) {
+    const tools = this.getToolDefinitions();
+    for (const tool of tools) {
+      if (!isToolEnabled(tool, filterConfig)) {
+        continue;
+      }
+      this.registerTool(server, tool);
+    }
+  }
+  /**
+   * Register a single tool with the MCP server.
+   * Uses modern registerTool() API for MCP 2025-11-25 compliance.
+   * Subclasses may override for custom behavior.
+   */
+  registerTool(server, tool) {
+    registerToolImpl(this, server, tool);
+  }
+  /**
+   * Register resources with the MCP server
+   */
+  registerResources(server) {
+    const resources = this.getResourceDefinitions();
+    for (const resource of resources) {
+      this.registerResource(server, resource);
+    }
+  }
+  /**
+   * Register a single resource with the MCP server.
+   * Handles both static resources and URI templates.
+   * Subclasses may override for custom behavior.
+   */
+  registerResource(server, resource) {
+    registerResourceImpl(this, server, resource);
+  }
+  /**
+   * Register prompts with the MCP server
+   */
+  registerPrompts(server) {
+    const prompts = this.getPromptDefinitions();
+    for (const prompt of prompts) {
+      this.registerPrompt(server, prompt);
+    }
+  }
+  /**
+   * Register a single prompt with the MCP server.
+   * Subclasses may override for custom behavior.
+   */
+  registerPrompt(server, prompt) {
+    registerPromptImpl(this, server, prompt);
+  }
+  // ===========================================================================
+  // Utility Methods
+  // ===========================================================================
+  /**
+   * Validate query for safety (SQL injection prevention)
+   * @param sql - SQL query to validate
+   * @param isReadOnly - Whether to enforce read-only restrictions
+   */
+  validateQuery(sql, isReadOnly) {
+    validateQuery(sql, isReadOnly);
+  }
+  /**
+   * Create a request context for tool execution
+   * @param requestId Optional request ID for tracing
+   * @param server Optional MCP Server instance for progress notifications
+   * @param progressToken Optional progress token from client request _meta
+   */
+  createContext(requestId, server, progressToken) {
+    const context = {
+      timestamp: /* @__PURE__ */ new Date(),
+      requestId: requestId ?? crypto.randomUUID()
+    };
+    if (server !== void 0) {
+      context.server = server;
+    }
+    if (progressToken !== void 0) {
+      context.progressToken = progressToken;
+    }
+    return context;
+  }
+  /**
+   * Ensure the adapter is connected to the database.
+   * Throws ConnectionError if not connected.
+   * Subclasses may override to add additional checks (e.g., db instance null).
+   */
+  ensureConnected() {
+    if (!this.connected) {
+      throw new ConnectionError(
+        "Not connected to database",
+        "DB_NOT_CONNECTED"
+      );
+    }
+  }
+  /**
+   * Get adapter info for logging/debugging
+   */
+  getInfo() {
+    return {
+      type: this.type,
+      name: this.name,
+      version: this.version,
+      connected: this.connected,
+      capabilities: this.getCapabilities(),
+      toolGroups: this.getSupportedToolGroups()
+    };
+  }
+};
+
+export { DatabaseAdapter };

package/dist/cli.d.ts

@@ -1,8 +1 @@
 #!/usr/bin/env node
-/**
- * db-mcp - Command Line Interface
- *
- * Entry point for running the db-mcp server from the command line.
- */
-export {};
-//# sourceMappingURL=cli.d.ts.map