@neverinfamous/mysql-mcp 2.3.1 → 3.0.1

package/src/adapters/mysql/tools/stats/descriptive.ts

@@ -6,13 +6,22 @@
  * 5 tools total.
  */
 
-import { z } from "zod";
+import { z, ZodError } from "zod";
 import type { MySQLAdapter } from "../../MySQLAdapter.js";
 import type {
   ToolDefinition,
   RequestContext,
 } from "../../../../types/index.js";
 
+// =============================================================================
+// Helpers
+// =============================================================================
+
+/** Extract human-readable messages from a ZodError instead of raw JSON array */
+function formatZodError(error: ZodError): string {
+  return error.issues.map((i) => i.message).join("; ");
+}
+
 // =============================================================================
 // Schemas
 // =============================================================================
@@ -44,14 +53,8 @@ const TimeSeriesSchema = z.object({
   table: z.string().describe("Table name"),
   valueColumn: z.string().describe("Numeric column for values"),
   timeColumn: z.string().describe("Timestamp/datetime column"),
-  interval: z
-    .enum(["minute", "hour", "day", "week", "month"])
-    .default("day")
-    .describe("Aggregation interval"),
-  aggregation: z
-    .enum(["avg", "sum", "count", "min", "max"])
-    .default("avg")
-    .describe("Aggregation function"),
+  interval: z.string().default("day").describe("Aggregation interval"),
+  aggregation: z.string().default("avg").describe("Aggregation function"),
   where: z.string().optional().describe("Optional WHERE clause condition"),
   limit: z.number().default(100).describe("Maximum number of data points"),
 });
@@ -90,19 +93,18 @@ export function createDescriptiveStatsTool(
       idempotentHint: true,
     },
     handler: async (params: unknown, _context: RequestContext) => {
-      const { table, column, where } = DescriptiveStatsSchema.parse(params);
-
-      // Validate identifiers
-      if (!/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(table)) {
-        throw new Error("Invalid table name");
-      }
-      if (!/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(column)) {
-        throw new Error("Invalid column name");
-      }
+      try {
+        const { table, column, where } = DescriptiveStatsSchema.parse(params);
+        // Validate identifiers
+        if (!/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(table)) {
+          return { success: false, error: "Invalid table name" };
+        }
+        if (!/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(column)) {
+          return { success: false, error: "Invalid column name" };
+        }
 
-      const whereClause = where ? `WHERE ${where}` : "";
+        const whereClause = where ? `WHERE ${where}` : "";
 
-      try {
         // Get basic count for median calculation
         const countResult = await adapter.executeQuery(
           `SELECT COUNT(*) as count FROM \`${table}\` ${whereClause}`,
@@ -175,9 +177,19 @@ export function createDescriptiveStatsTool(
           sum: stats?.["sum"] ?? null,
         };
       } catch (error) {
-        const msg = error instanceof Error ? error.message : String(error);
+        if (error instanceof ZodError) {
+          return { success: false, error: formatZodError(error) };
+        }
+        const msg = (error instanceof Error ? error.message : String(error))
+          .replace(/^Query failed: /, "")
+          .replace(/^Execute failed: /, "");
         if (msg.includes("doesn't exist")) {
-          return { exists: false, table };
+          return {
+            exists: false,
+            table:
+              ((params as Record<string, unknown>)?.["table"] as string) ??
+              "unknown",
+          };
         }
         return { success: false, error: msg };
       }
@@ -201,20 +213,19 @@ export function createPercentilesTool(adapter: MySQLAdapter): ToolDefinition {
       idempotentHint: true,
     },
     handler: async (params: unknown, _context: RequestContext) => {
-      const { table, column, percentiles, where } =
-        PercentilesSchema.parse(params);
-
-      // Validate identifiers
-      if (!/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(table)) {
-        throw new Error("Invalid table name");
-      }
-      if (!/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(column)) {
-        throw new Error("Invalid column name");
-      }
+      try {
+        const { table, column, percentiles, where } =
+          PercentilesSchema.parse(params);
+        // Validate identifiers
+        if (!/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(table)) {
+          return { success: false, error: "Invalid table name" };
+        }
+        if (!/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(column)) {
+          return { success: false, error: "Invalid column name" };
+        }
 
-      const whereClause = where ? `WHERE ${where}` : "";
+        const whereClause = where ? `WHERE ${where}` : "";
 
-      try {
         // Get total count
         const countResult = await adapter.executeQuery(
           `SELECT COUNT(*) as cnt FROM \`${table}\` ${whereClause}`,
@@ -253,9 +264,19 @@ export function createPercentilesTool(adapter: MySQLAdapter): ToolDefinition {
           percentiles: percentileResults,
         };
       } catch (error) {
-        const msg = error instanceof Error ? error.message : String(error);
+        if (error instanceof ZodError) {
+          return { success: false, error: formatZodError(error) };
+        }
+        const msg = (error instanceof Error ? error.message : String(error))
+          .replace(/^Query failed: /, "")
+          .replace(/^Execute failed: /, "");
         if (msg.includes("doesn't exist")) {
-          return { exists: false, table };
+          return {
+            exists: false,
+            table:
+              ((params as Record<string, unknown>)?.["table"] as string) ??
+              "unknown",
+          };
         }
         return { success: false, error: msg };
       }
@@ -280,20 +301,22 @@ export function createDistributionTool(adapter: MySQLAdapter): ToolDefinition {
       idempotentHint: true,
     },
     handler: async (params: unknown, _context: RequestContext) => {
-      const { table, column, buckets, where } =
-        DistributionSchema.parse(params);
-
-      // Validate identifiers
-      if (!/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(table)) {
-        throw new Error("Invalid table name");
-      }
-      if (!/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(column)) {
-        throw new Error("Invalid column name");
-      }
+      try {
+        const { table, column, buckets, where } =
+          DistributionSchema.parse(params);
+        // Validate identifiers
+        if (!/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(table)) {
+          return { success: false, error: "Invalid table name" };
+        }
+        if (!/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(column)) {
+          return { success: false, error: "Invalid column name" };
+        }
+        if (buckets < 1) {
+          return { success: false, error: "buckets must be at least 1" };
+        }
 
-      const whereClause = where ? `WHERE ${where}` : "";
+        const whereClause = where ? `WHERE ${where}` : "";
 
-      try {
         // Get min/max for bucket calculation
         const rangeResult = await adapter.executeQuery(
           `SELECT MIN(\`${column}\`) as min_val, MAX(\`${column}\`) as max_val FROM \`${table}\` ${whereClause}`,
@@ -356,9 +379,19 @@ export function createDistributionTool(adapter: MySQLAdapter): ToolDefinition {
           maxValue: maxVal,
         };
       } catch (error) {
-        const msg = error instanceof Error ? error.message : String(error);
+        if (error instanceof ZodError) {
+          return { success: false, error: formatZodError(error) };
+        }
+        const msg = (error instanceof Error ? error.message : String(error))
+          .replace(/^Query failed: /, "")
+          .replace(/^Execute failed: /, "");
         if (msg.includes("doesn't exist")) {
-          return { exists: false, table };
+          return {
+            exists: false,
+            table:
+              ((params as Record<string, unknown>)?.["table"] as string) ??
+              "unknown",
+          };
         }
         return { success: false, error: msg };
       }
@@ -385,50 +418,68 @@ export function createTimeSeriesToolStats(
       idempotentHint: true,
     },
     handler: async (params: unknown, _context: RequestContext) => {
-      const {
-        table,
-        valueColumn,
-        timeColumn,
-        interval,
-        aggregation,
-        where,
-        limit,
-      } = TimeSeriesSchema.parse(params);
-
-      // Validate identifiers
-      if (!/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(table)) {
-        throw new Error("Invalid table name");
-      }
-      if (
-        !/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(valueColumn) ||
-        !/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(timeColumn)
-      ) {
-        throw new Error("Invalid column name");
-      }
+      try {
+        const {
+          table,
+          valueColumn,
+          timeColumn,
+          interval,
+          aggregation,
+          where,
+          limit,
+        } = TimeSeriesSchema.parse(params);
 
-      let dateFormat: string;
-      switch (interval) {
-        case "minute":
-          dateFormat = "%Y-%m-%d %H:%i:00";
-          break;
-        case "hour":
-          dateFormat = "%Y-%m-%d %H:00:00";
-          break;
-        case "day":
-          dateFormat = "%Y-%m-%d";
-          break;
-        case "week":
-          dateFormat = "%x-W%v";
-          break;
-        case "month":
-          dateFormat = "%Y-%m";
-          break;
-      }
+        // Validate identifiers
+        if (!/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(table)) {
+          return { success: false, error: "Invalid table name" };
+        }
+        if (
+          !/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(valueColumn) ||
+          !/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(timeColumn)
+        ) {
+          return { success: false, error: "Invalid column name" };
+        }
 
-      const whereClause = where ? `WHERE ${where}` : "";
-      const aggFunc = aggregation.toUpperCase();
+        const validIntervals = ["minute", "hour", "day", "week", "month"];
+        if (!validIntervals.includes(interval)) {
+          return {
+            success: false,
+            error: `Invalid interval: '${interval}' — expected one of: ${validIntervals.join(", ")}`,
+          };
+        }
+        const validAggregations = ["avg", "sum", "count", "min", "max"];
+        if (!validAggregations.includes(aggregation)) {
+          return {
+            success: false,
+            error: `Invalid aggregation: '${aggregation}' — expected one of: ${validAggregations.join(", ")}`,
+          };
+        }
 
-      const query = `
+        let dateFormat: string;
+        switch (interval) {
+          case "minute":
+            dateFormat = "%Y-%m-%d %H:%i:00";
+            break;
+          case "hour":
+            dateFormat = "%Y-%m-%d %H:00:00";
+            break;
+          case "day":
+            dateFormat = "%Y-%m-%d";
+            break;
+          case "week":
+            dateFormat = "%x-W%v";
+            break;
+          case "month":
+            dateFormat = "%Y-%m";
+            break;
+          default:
+            dateFormat = "%Y-%m-%d";
+        }
+
+        const whereClause = where ? `WHERE ${where}` : "";
+        const aggFunc = aggregation.toUpperCase();
+
+        const query = `
                 SELECT 
                     DATE_FORMAT(\`${timeColumn}\`, '${dateFormat}') as period,
                     ${aggFunc}(\`${valueColumn}\`) as value,
@@ -441,8 +492,6 @@ export function createTimeSeriesToolStats(
                 ORDER BY period DESC
                 LIMIT ${String(limit)}
             `;
-
-      try {
         const result = await adapter.executeQuery(query);
 
         return {
@@ -454,9 +503,19 @@ export function createTimeSeriesToolStats(
           count: result.rows?.length ?? 0,
         };
       } catch (error) {
-        const msg = error instanceof Error ? error.message : String(error);
+        if (error instanceof ZodError) {
+          return { success: false, error: formatZodError(error) };
+        }
+        const msg = (error instanceof Error ? error.message : String(error))
+          .replace(/^Query failed: /, "")
+          .replace(/^Execute failed: /, "");
         if (msg.includes("doesn't exist")) {
-          return { exists: false, table };
+          return {
+            exists: false,
+            table:
+              ((params as Record<string, unknown>)?.["table"] as string) ??
+              "unknown",
+          };
         }
         return { success: false, error: msg };
       }
@@ -480,50 +539,58 @@ export function createSamplingTool(adapter: MySQLAdapter): ToolDefinition {
       idempotentHint: false, // Random results
     },
     handler: async (params: unknown, _context: RequestContext) => {
-      const { table, sampleSize, columns, seed, where } =
-        SamplingSchema.parse(params);
+      try {
+        const { table, sampleSize, columns, seed, where } =
+          SamplingSchema.parse(params);
 
-      // Validate table name
-      if (!/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(table)) {
-        throw new Error("Invalid table name");
-      }
+        if (sampleSize < 0) {
+          return { success: false, error: "sampleSize must be >= 0" };
+        }
+
+        // Validate table name
+        if (!/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(table)) {
+          return { success: false, error: "Invalid table name" };
+        }
 
-      // Validate column names if provided
-      const columnList =
-        columns !== undefined && columns.length > 0
-          ? columns
-              .map((c) => {
-                if (!/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(c)) {
-                  throw new Error(`Invalid column name: ${c}`);
-                }
-                return `\`${c}\``;
-              })
-              .join(", ")
-          : "*";
-
-      const whereClause = where ? `WHERE ${where}` : "";
-
-      // If seed is provided, use it for reproducibility
-      let query: string;
-      if (seed !== undefined) {
-        query = `
+        // Validate column names if provided
+        if (columns) {
+          for (const c of columns) {
+            if (!/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(c)) {
+              return { success: false, error: `Invalid column name: ${c}` };
+            }
+          }
+        }
+
+        const columnList =
+          columns !== undefined && columns.length > 0
+            ? columns
+                .map((c) => {
+                  return `\`${c}\``;
+                })
+                .join(", ")
+            : "*";
+
+        const whereClause = where ? `WHERE ${where}` : "";
+
+        // If seed is provided, use it for reproducibility
+        let query: string;
+        if (seed !== undefined) {
+          query = `
                     SELECT ${columnList}
                     FROM \`${table}\`
                     ${whereClause}
                     ORDER BY RAND(${String(seed)})
                     LIMIT ${String(sampleSize)}
                 `;
-      } else {
-        query = `
+        } else {
+          query = `
                     SELECT ${columnList}
                     FROM \`${table}\`
                     ${whereClause}
                     ORDER BY RAND()
                     LIMIT ${String(sampleSize)}
                 `;
-      }
-
-      try {
+        }
         const result = await adapter.executeQuery(query);
 
         return {
@@ -533,9 +600,19 @@ export function createSamplingTool(adapter: MySQLAdapter): ToolDefinition {
           seed: seed ?? null,
         };
       } catch (error) {
-        const msg = error instanceof Error ? error.message : String(error);
+        if (error instanceof ZodError) {
+          return { success: false, error: formatZodError(error) };
+        }
+        const msg = (error instanceof Error ? error.message : String(error))
+          .replace(/^Query failed: /, "")
+          .replace(/^Execute failed: /, "");
         if (msg.includes("doesn't exist")) {
-          return { exists: false, table };
+          return {
+            exists: false,
+            table:
+              ((params as Record<string, unknown>)?.["table"] as string) ??
+              "unknown",
+          };
         }
         return { success: false, error: msg };
       }

package/src/adapters/mysql/tools/sysschema/__tests__/error-paths.test.ts

@@ -0,0 +1,222 @@
+/**
+ * mysql-mcp - Sys Schema Error Path Tests
+ *
+ * Tests for error handling (ZodError, database errors) across all sysschema tools.
+ * These tests specifically target the catch blocks that are missed by happy-path tests.
+ */
+
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import {
+  createSysUserSummaryTool,
+  createSysHostSummaryTool,
+} from "../activity.js";
+import {
+  createSysStatementSummaryTool,
+  createSysWaitSummaryTool,
+  createSysIOSummaryTool,
+} from "../performance.js";
+import {
+  createSysSchemaStatsTool,
+  createSysInnoDBLockWaitsTool,
+  createSysMemorySummaryTool,
+} from "../resources.js";
+import type { MySQLAdapter } from "../../../MySQLAdapter.js";
+import {
+  createMockMySQLAdapter,
+  createMockRequestContext,
+} from "../../../../../__tests__/mocks/index.js";
+
+describe("Sys Schema Error Paths", () => {
+  let mockAdapter: ReturnType<typeof createMockMySQLAdapter>;
+  let mockContext: ReturnType<typeof createMockRequestContext>;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mockAdapter = createMockMySQLAdapter();
+    mockContext = createMockRequestContext();
+  });
+
+  // ===========================================================================
+  // Activity tools error paths
+  // ===========================================================================
+  describe("activity error paths", () => {
+    it("should handle database error in user summary", async () => {
+      mockAdapter.executeQuery.mockRejectedValue(
+        new Error("DB connection lost"),
+      );
+      const tool = createSysUserSummaryTool(
+        mockAdapter as unknown as MySQLAdapter,
+      );
+      const result = (await tool.handler({}, mockContext)) as {
+        success: boolean;
+        error: string;
+      };
+      expect(result.success).toBe(false);
+      expect(result.error).toContain("DB connection lost");
+    });
+
+    it("should handle non-Error thrown in user summary", async () => {
+      mockAdapter.executeQuery.mockRejectedValue("string error");
+      const tool = createSysUserSummaryTool(
+        mockAdapter as unknown as MySQLAdapter,
+      );
+      const result = (await tool.handler({}, mockContext)) as {
+        success: boolean;
+        error: string;
+      };
+      expect(result.success).toBe(false);
+      expect(result.error).toBe("string error");
+    });
+
+    it("should handle database error in host summary", async () => {
+      mockAdapter.executeQuery.mockRejectedValue(new Error("DB timeout"));
+      const tool = createSysHostSummaryTool(
+        mockAdapter as unknown as MySQLAdapter,
+      );
+      const result = (await tool.handler({}, mockContext)) as {
+        success: boolean;
+        error: string;
+      };
+      expect(result.success).toBe(false);
+      expect(result.error).toContain("DB timeout");
+    });
+
+    it("should handle non-Error thrown in host summary", async () => {
+      mockAdapter.executeQuery.mockRejectedValue(42);
+      const tool = createSysHostSummaryTool(
+        mockAdapter as unknown as MySQLAdapter,
+      );
+      const result = (await tool.handler({}, mockContext)) as {
+        success: boolean;
+        error: string;
+      };
+      expect(result.success).toBe(false);
+      expect(result.error).toBe("42");
+    });
+  });
+
+  // ===========================================================================
+  // Performance tools error paths
+  // ===========================================================================
+  describe("performance error paths", () => {
+    it("should handle database error in statement summary", async () => {
+      mockAdapter.executeQuery.mockRejectedValue(new Error("Query failed"));
+      const tool = createSysStatementSummaryTool(
+        mockAdapter as unknown as MySQLAdapter,
+      );
+      const result = (await tool.handler({}, mockContext)) as {
+        success: boolean;
+        error: string;
+      };
+      expect(result.success).toBe(false);
+      expect(result.error).toContain("Query failed");
+    });
+
+    it("should handle database error in wait summary", async () => {
+      mockAdapter.executeQuery.mockRejectedValue(new Error("Wait query error"));
+      const tool = createSysWaitSummaryTool(
+        mockAdapter as unknown as MySQLAdapter,
+      );
+      const result = (await tool.handler({}, mockContext)) as {
+        success: boolean;
+        error: string;
+      };
+      expect(result.success).toBe(false);
+      expect(result.error).toContain("Wait query error");
+    });
+
+    it("should handle database error in IO summary", async () => {
+      mockAdapter.executeQuery.mockRejectedValue(new Error("IO query error"));
+      const tool = createSysIOSummaryTool(
+        mockAdapter as unknown as MySQLAdapter,
+      );
+      const result = (await tool.handler({}, mockContext)) as {
+        success: boolean;
+        error: string;
+      };
+      expect(result.success).toBe(false);
+      expect(result.error).toContain("IO query error");
+    });
+
+    it("should handle non-Error thrown in statement summary", async () => {
+      mockAdapter.executeQuery.mockRejectedValue("raw string");
+      const tool = createSysStatementSummaryTool(
+        mockAdapter as unknown as MySQLAdapter,
+      );
+      const result = (await tool.handler({}, mockContext)) as {
+        success: boolean;
+        error: string;
+      };
+      expect(result.success).toBe(false);
+      expect(result.error).toBe("raw string");
+    });
+  });
+
+  // ===========================================================================
+  // Resources tools error paths
+  // ===========================================================================
+  describe("resources error paths", () => {
+    it("should handle database error in schema stats", async () => {
+      mockAdapter.executeQuery.mockRejectedValue(new Error("Schema error"));
+      const tool = createSysSchemaStatsTool(
+        mockAdapter as unknown as MySQLAdapter,
+      );
+      const result = (await tool.handler({}, mockContext)) as {
+        success: boolean;
+        error: string;
+      };
+      expect(result.success).toBe(false);
+      expect(result.error).toContain("Schema error");
+    });
+
+    it("should handle database error in innodb lock waits", async () => {
+      mockAdapter.executeQuery.mockRejectedValue(new Error("Lock error"));
+      const tool = createSysInnoDBLockWaitsTool(
+        mockAdapter as unknown as MySQLAdapter,
+      );
+      const result = (await tool.handler({}, mockContext)) as {
+        success: boolean;
+        error: string;
+      };
+      expect(result.success).toBe(false);
+      expect(result.error).toContain("Lock error");
+    });
+
+    it("should handle database error in memory summary", async () => {
+      mockAdapter.executeQuery.mockRejectedValue(new Error("Memory error"));
+      const tool = createSysMemorySummaryTool(
+        mockAdapter as unknown as MySQLAdapter,
+      );
+      const result = (await tool.handler({}, mockContext)) as {
+        success: boolean;
+        error: string;
+      };
+      expect(result.success).toBe(false);
+      expect(result.error).toContain("Memory error");
+    });
+
+    it("should handle non-Error thrown in lock waits", async () => {
+      mockAdapter.executeQuery.mockRejectedValue({ code: "UNKNOWN" });
+      const tool = createSysInnoDBLockWaitsTool(
+        mockAdapter as unknown as MySQLAdapter,
+      );
+      const result = (await tool.handler({}, mockContext)) as {
+        success: boolean;
+        error: string;
+      };
+      expect(result.success).toBe(false);
+    });
+
+    it("should handle non-Error thrown in memory summary", async () => {
+      mockAdapter.executeQuery.mockRejectedValue(undefined);
+      const tool = createSysMemorySummaryTool(
+        mockAdapter as unknown as MySQLAdapter,
+      );
+      const result = (await tool.handler({}, mockContext)) as {
+        success: boolean;
+        error: string;
+      };
+      expect(result.success).toBe(false);
+    });
+  });
+});