@neverinfamous/mysql-mcp 2.3.0 → 3.0.0

package/src/adapters/mysql/tools/performance/__tests__/optimization.test.ts

@@ -435,6 +435,27 @@ describe("Performance Optimization Tools", () => {
       );
     });
 
+    it("should strip adapter prefix from query execution error", async () => {
+      mockAdapter.executeReadQuery.mockRejectedValue(
+        new Error(
+          "Query failed: Execute failed: Table 'testdb.ghost' doesn't exist",
+        ),
+      );
+
+      const tool = createOptimizerTraceTool(
+        mockAdapter as unknown as MySQLAdapter,
+      );
+
+      const result = (await tool.handler(
+        { query: "SELECT * FROM ghost" },
+        mockContext,
+      )) as { query: string; trace: null; error: string };
+
+      expect(result.query).toBe("SELECT * FROM ghost");
+      expect(result.trace).toBeNull();
+      expect(result.error).toBe("Table 'testdb.ghost' doesn't exist");
+    });
+
     it("should accept sql alias for query parameter", async () => {
       mockAdapter.executeReadQuery
         .mockResolvedValueOnce(createMockQueryResult([])) // The query
@@ -454,5 +475,171 @@ describe("Performance Optimization Tools", () => {
       );
       expect(result).toHaveProperty("trace");
     });
+
+    it("should return structured error when trace fetch fails", async () => {
+      mockAdapter.executeReadQuery
+        .mockResolvedValueOnce(createMockQueryResult([])) // The query succeeds
+        .mockRejectedValueOnce(new Error("Access denied for OPTIMIZER_TRACE")); // The trace fetch fails
+
+      const tool = createOptimizerTraceTool(
+        mockAdapter as unknown as MySQLAdapter,
+      );
+      const result = (await tool.handler(
+        { query: "SELECT * FROM users" },
+        mockContext,
+      )) as { success: boolean; error: string };
+
+      expect(result.success).toBe(false);
+      expect(result.error).toBe("Access denied for OPTIMIZER_TRACE");
+
+      // Verify optimizer trace is still disabled in finally block
+      expect(mockAdapter.executeQuery).toHaveBeenCalledWith(
+        'SET optimizer_trace="enabled=off"',
+      );
+    });
+  });
+
+  describe("alias support", () => {
+    it("mysql_index_recommendation should accept tableName alias", async () => {
+      const mockTableInfo = createMockTableInfo("orders");
+      mockTableInfo.columns = [
+        { name: "id", type: "int", nullable: false, primaryKey: true },
+      ];
+      mockAdapter.describeTable.mockResolvedValue(mockTableInfo);
+      mockAdapter.getTableIndexes.mockResolvedValue([
+        {
+          name: "PRIMARY",
+          tableName: "orders",
+          columns: ["id"],
+          unique: true,
+          type: "BTREE",
+        },
+      ]);
+
+      const tool = createIndexRecommendationTool(
+        mockAdapter as unknown as MySQLAdapter,
+      );
+      const result = (await tool.handler(
+        { tableName: "orders" },
+        mockContext,
+      )) as { exists: boolean; table: string };
+
+      expect(result.exists).toBe(true);
+      expect(result.table).toBe("orders");
+      expect(mockAdapter.describeTable).toHaveBeenCalledWith("orders");
+    });
+
+    it("mysql_force_index should accept tableName alias", async () => {
+      const mockTableInfo = createMockTableInfo("users");
+      mockTableInfo.columns = [
+        { name: "id", type: "int", nullable: false, primaryKey: true },
+      ];
+      mockAdapter.describeTable.mockResolvedValue(mockTableInfo);
+      mockAdapter.getTableIndexes.mockResolvedValue([
+        {
+          name: "idx_name",
+          tableName: "users",
+          columns: ["name"],
+          unique: false,
+          type: "BTREE",
+        },
+      ]);
+
+      const tool = createForceIndexTool(mockAdapter as unknown as MySQLAdapter);
+      const result = (await tool.handler(
+        {
+          tableName: "users",
+          query: "SELECT * FROM users WHERE name = 'test'",
+          indexName: "idx_name",
+        },
+        mockContext,
+      )) as { rewrittenQuery: string };
+
+      expect(result.rewrittenQuery).toContain("FORCE INDEX");
+      expect(mockAdapter.describeTable).toHaveBeenCalledWith("users");
+    });
+  });
+
+  describe("try/catch error handling", () => {
+    it("mysql_index_recommendation should return structured error on adapter throw", async () => {
+      mockAdapter.describeTable.mockRejectedValue(new Error("Connection lost"));
+
+      const tool = createIndexRecommendationTool(
+        mockAdapter as unknown as MySQLAdapter,
+      );
+      const result = (await tool.handler({ table: "users" }, mockContext)) as {
+        success: boolean;
+        error: string;
+      };
+
+      expect(result.success).toBe(false);
+      expect(result.error).toBe("Connection lost");
+    });
+
+    it("mysql_force_index should return structured error on adapter throw", async () => {
+      mockAdapter.describeTable.mockRejectedValue(new Error("Connection lost"));
+
+      const tool = createForceIndexTool(mockAdapter as unknown as MySQLAdapter);
+      const result = (await tool.handler(
+        {
+          table: "users",
+          query: "SELECT * FROM users",
+          indexName: "idx_name",
+        },
+        mockContext,
+      )) as { success: boolean; error: string };
+
+      expect(result.success).toBe(false);
+      expect(result.error).toBe("Connection lost");
+    });
+
+    it("mysql_query_rewrite should return structured error on parse failure", async () => {
+      const tool = createQueryRewriteTool(
+        mockAdapter as unknown as MySQLAdapter,
+      );
+      const result = (await tool.handler({}, mockContext)) as {
+        success: boolean;
+        error: string;
+      };
+
+      expect(result.success).toBe(false);
+      expect(result.error).toBeDefined();
+    });
+
+    it("mysql_optimizer_trace should return structured error on missing query", async () => {
+      const tool = createOptimizerTraceTool(
+        mockAdapter as unknown as MySQLAdapter,
+      );
+      const result = (await tool.handler({}, mockContext)) as {
+        success: boolean;
+        error: string;
+      };
+
+      expect(result.success).toBe(false);
+      expect(result.error).toBeDefined();
+      // Verify optimizer trace was never enabled (parse failed before SET)
+      expect(mockAdapter.executeQuery).not.toHaveBeenCalledWith(
+        'SET optimizer_trace="enabled=on"',
+      );
+    });
+
+    it("mysql_query_rewrite should strip adapter prefix from explainError", async () => {
+      mockAdapter.executeReadQuery.mockRejectedValue(
+        new Error(
+          "Query failed: Execute failed: Table 'testdb.ghost' doesn't exist",
+        ),
+      );
+
+      const tool = createQueryRewriteTool(
+        mockAdapter as unknown as MySQLAdapter,
+      );
+      const result = (await tool.handler(
+        { query: "SELECT * FROM ghost" },
+        mockContext,
+      )) as { explainPlan: unknown; explainError: string };
+
+      expect(result.explainPlan).toBeNull();
+      expect(result.explainError).toBe("Table 'testdb.ghost' doesn't exist");
+    });
   });
 });

package/src/adapters/mysql/tools/performance/analysis.ts

@@ -16,6 +16,7 @@ import {
   ExplainAnalyzeSchema,
   ExplainAnalyzeSchemaBase,
   SlowQuerySchema,
+  QueryStatsSchema,
   IndexUsageSchema,
   IndexUsageSchemaBase,
   TableStatsSchema,
@@ -163,7 +164,8 @@ export function createSlowQueriesTool(adapter: MySQLAdapter): ToolDefinition {
     handler: async (params: unknown, _context: RequestContext) => {
       const { limit, minTime } = SlowQuerySchema.parse(params);
 
-      let sql = `
+      try {
+        let sql = `
                 SELECT 
                     LEFT(DIGEST_TEXT, 200) as query,
                     COUNT_STAR as executions,
@@ -174,53 +176,50 @@ export function createSlowQueriesTool(adapter: MySQLAdapter): ToolDefinition {
                 FROM performance_schema.events_statements_summary_by_digest
             `;
 
-      if (minTime !== undefined) {
-        sql += ` WHERE AVG_TIMER_WAIT > ${minTime * 1000000000}`;
-      }
+        if (minTime !== undefined) {
+          sql += ` WHERE AVG_TIMER_WAIT > ${minTime * 1000000000000}`;
+        }
 
-      sql += ` ORDER BY AVG_TIMER_WAIT DESC LIMIT ${limit}`;
+        sql += ` ORDER BY AVG_TIMER_WAIT DESC LIMIT ${limit}`;
 
-      const result = await adapter.executeReadQuery(sql);
-      return {
-        slowQueries: sanitizeTimerRows(result.rows, [
-          "avg_time_ms",
-          "total_time_ms",
-        ]),
-      };
+        const result = await adapter.executeReadQuery(sql);
+        return {
+          slowQueries: sanitizeTimerRows(result.rows, [
+            "avg_time_ms",
+            "total_time_ms",
+          ]),
+        };
+      } catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        return { success: false, error: msg };
+      }
     },
   };
 }
 
 export function createQueryStatsTool(adapter: MySQLAdapter): ToolDefinition {
-  const schema = z.object({
-    orderBy: z
-      .enum(["total_time", "avg_time", "executions"])
-      .optional()
-      .default("total_time"),
-    limit: z.number().optional().default(10),
-  });
-
   return {
     name: "mysql_query_stats",
     title: "MySQL Query Stats",
     description: "Get query statistics from performance_schema.",
     group: "performance",
-    inputSchema: schema,
+    inputSchema: QueryStatsSchema,
     requiredScopes: ["read"],
     annotations: {
       readOnlyHint: true,
       idempotentHint: true,
     },
     handler: async (params: unknown, _context: RequestContext) => {
-      const { orderBy, limit } = schema.parse(params);
+      const { orderBy, limit } = QueryStatsSchema.parse(params);
 
-      const orderColumn = {
-        total_time: "SUM_TIMER_WAIT",
-        avg_time: "AVG_TIMER_WAIT",
-        executions: "COUNT_STAR",
-      }[orderBy];
+      try {
+        const orderColumn = {
+          total_time: "SUM_TIMER_WAIT",
+          avg_time: "AVG_TIMER_WAIT",
+          executions: "COUNT_STAR",
+        }[orderBy];
 
-      const sql = `
+        const sql = `
                 SELECT 
                     SCHEMA_NAME as database_name,
                     LEFT(DIGEST_TEXT, 200) as query_text,
@@ -238,14 +237,18 @@ export function createQueryStatsTool(adapter: MySQLAdapter): ToolDefinition {
                 LIMIT ${limit}
             `;
 
-      const result = await adapter.executeReadQuery(sql);
-      return {
-        queries: sanitizeTimerRows(result.rows, [
-          "avg_time_ms",
-          "max_time_ms",
-          "total_time_ms",
-        ]),
-      };
+        const result = await adapter.executeReadQuery(sql);
+        return {
+          queries: sanitizeTimerRows(result.rows, [
+            "avg_time_ms",
+            "max_time_ms",
+            "total_time_ms",
+          ]),
+        };
+      } catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        return { success: false, error: msg };
+      }
     },
   };
 }
@@ -263,22 +266,23 @@ export function createIndexUsageTool(adapter: MySQLAdapter): ToolDefinition {
       idempotentHint: true,
     },
     handler: async (params: unknown, _context: RequestContext) => {
-      const { table, limit } = IndexUsageSchema.parse(params);
-
-      // P154: Check table existence when a specific table is requested
-      if (table) {
-        const check = await adapter.executeReadQuery(
-          `SELECT 1 FROM information_schema.TABLES WHERE TABLE_SCHEMA = DATABASE() AND TABLE_NAME = ?`,
-          [table],
-        );
-        if (!check.rows || check.rows.length === 0) {
-          return { exists: false, table };
+      try {
+        const { table, limit } = IndexUsageSchema.parse(params);
+
+        // P154: Check table existence when a specific table is requested
+        if (table) {
+          const check = await adapter.executeReadQuery(
+            `SELECT 1 FROM information_schema.TABLES WHERE TABLE_SCHEMA = DATABASE() AND TABLE_NAME = ?`,
+            [table],
+          );
+          if (!check.rows || check.rows.length === 0) {
+            return { exists: false, table };
+          }
         }
-      }
 
-      // Always filter to current database to avoid returning thousands of
-      // MySQL internal indexes with zero counts
-      let sql = `
+        // Always filter to current database to avoid returning thousands of
+        // MySQL internal indexes with zero counts
+        let sql = `
                 SELECT 
                     object_schema as database_name,
                     object_name as table_name,
@@ -294,14 +298,21 @@ export function createIndexUsageTool(adapter: MySQLAdapter): ToolDefinition {
                   AND object_schema = DATABASE()
             `;
 
-      if (table) {
-        sql += ` AND object_name = ?`;
-      }
+        if (table) {
+          sql += ` AND object_name = ?`;
+        }
 
-      sql += ` ORDER BY count_read + count_write DESC LIMIT ${limit}`;
+        sql += ` ORDER BY count_read + count_write DESC LIMIT ${limit}`;
 
-      const result = await adapter.executeReadQuery(sql, table ? [table] : []);
-      return { indexUsage: result.rows };
+        const result = await adapter.executeReadQuery(
+          sql,
+          table ? [table] : [],
+        );
+        return { indexUsage: result.rows };
+      } catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        return { success: false, error: msg };
+      }
     },
   };
 }
@@ -320,9 +331,10 @@ export function createTableStatsTool(adapter: MySQLAdapter): ToolDefinition {
       idempotentHint: true,
     },
     handler: async (params: unknown, _context: RequestContext) => {
-      const { table } = TableStatsSchema.parse(params);
+      try {
+        const { table } = TableStatsSchema.parse(params);
 
-      const sql = `
+        const sql = `
                 SELECT 
                     TABLE_NAME as table_name,
                     ENGINE as engine,
@@ -341,13 +353,17 @@ export function createTableStatsTool(adapter: MySQLAdapter): ToolDefinition {
                   AND TABLE_NAME = ?
             `;
 
-      const result = await adapter.executeReadQuery(sql, [table]);
+        const result = await adapter.executeReadQuery(sql, [table]);
 
-      if (!result.rows || result.rows.length === 0) {
-        return { exists: false, table };
-      }
+        if (!result.rows || result.rows.length === 0) {
+          return { exists: false, table };
+        }
 
-      return { stats: result.rows[0] };
+        return { stats: result.rows[0] };
+      } catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        return { success: false, error: msg };
+      }
     },
   };
 }
@@ -369,8 +385,9 @@ export function createBufferPoolStatsTool(
       idempotentHint: true,
     },
     handler: async (_params: unknown, _context: RequestContext) => {
-      const result = await adapter.executeReadQuery(
-        `SELECT POOL_ID, POOL_SIZE, FREE_BUFFERS, DATABASE_PAGES,
+      try {
+        const result = await adapter.executeReadQuery(
+          `SELECT POOL_ID, POOL_SIZE, FREE_BUFFERS, DATABASE_PAGES,
                 OLD_DATABASE_PAGES, MODIFIED_DATABASE_PAGES, PENDING_DECOMPRESS,
                 PENDING_READS, PENDING_FLUSH_LRU, PENDING_FLUSH_LIST,
                 PAGES_MADE_YOUNG, PAGES_NOT_MADE_YOUNG,
@@ -380,9 +397,13 @@ export function createBufferPoolStatsTool(
                 HIT_RATE, YOUNG_MAKE_PER_THOUSAND_GETS,
                 NOT_YOUNG_MAKE_PER_THOUSAND_GETS
          FROM information_schema.INNODB_BUFFER_POOL_STATS`,
-      );
+        );
 
-      return { bufferPoolStats: result.rows };
+        return { bufferPoolStats: result.rows };
+      } catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        return { success: false, error: msg };
+      }
     },
   };
 }
@@ -402,7 +423,8 @@ export function createThreadStatsTool(adapter: MySQLAdapter): ToolDefinition {
       idempotentHint: true,
     },
     handler: async (_params: unknown, _context: RequestContext) => {
-      const result = await adapter.executeReadQuery(`
+      try {
+        const result = await adapter.executeReadQuery(`
                 SELECT 
                     THREAD_ID,
                     NAME,
@@ -420,7 +442,11 @@ export function createThreadStatsTool(adapter: MySQLAdapter): ToolDefinition {
                 ORDER BY PROCESSLIST_TIME DESC
             `);
 
-      return { threads: result.rows };
+        return { threads: result.rows };
+      } catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        return { success: false, error: msg };
+      }
     },
   };
 }