@neverinfamous/mysql-mcp 2.3.0 → 3.0.0

package/src/adapters/mysql/tools/cluster/__tests__/group-replication.test.ts

@@ -1,6 +1,9 @@
 import { describe, it, expect, vi, beforeEach, type Mock } from "vitest";
 import {
   createGRStatusTool,
+  createGRMembersTool,
+  createGRPrimaryTool,
+  createGRTransactionsTool,
   createGRFlowControlTool,
 } from "../group-replication.js";
 import { MySQLAdapter } from "../../../MySQLAdapter.js";
@@ -216,3 +219,69 @@ describe("Group Replication Tools", () => {
     });
   });
 });
+
+describe("Group Replication Tools - Error Handling", () => {
+  let mockAdapter: MySQLAdapter;
+  let mockExecuteQuery: Mock;
+
+  beforeEach(() => {
+    mockExecuteQuery = vi.fn();
+    mockAdapter = {
+      executeQuery: mockExecuteQuery,
+    } as unknown as MySQLAdapter;
+  });
+
+  it("mysql_gr_status should return structured error when query fails", async () => {
+    const tool = createGRStatusTool(mockAdapter);
+    mockExecuteQuery.mockRejectedValue(new Error("Connection refused"));
+
+    const result = (await tool.handler({}, {} as any)) as any;
+
+    expect(result.enabled).toBe(false);
+    expect(result.error).toBe("Connection refused");
+  });
+
+  it("mysql_gr_members should return structured error when query fails", async () => {
+    const tool = createGRMembersTool(mockAdapter);
+    mockExecuteQuery.mockRejectedValue(new Error("Access denied"));
+
+    const result = (await tool.handler({}, {} as any)) as any;
+
+    expect(result.members).toEqual([]);
+    expect(result.count).toBe(0);
+    expect(result.error).toBe("Access denied");
+  });
+
+  it("mysql_gr_primary should return structured error when query fails", async () => {
+    const tool = createGRPrimaryTool(mockAdapter);
+    mockExecuteQuery.mockRejectedValue(new Error("Connection lost"));
+
+    const result = (await tool.handler({}, {} as any)) as any;
+
+    expect(result.hasPrimary).toBe(false);
+    expect(result.error).toBe("Connection lost");
+  });
+
+  it("mysql_gr_transactions should return structured error when query fails", async () => {
+    const tool = createGRTransactionsTool(mockAdapter);
+    mockExecuteQuery.mockRejectedValue(new Error("Permission denied"));
+
+    const result = (await tool.handler({}, {} as any)) as any;
+
+    expect(result.memberStats).toEqual([]);
+    expect(result.gtid).toEqual({ executed: "", purged: "" });
+    expect(result.error).toBe("Permission denied");
+  });
+
+  it("mysql_gr_flow_control should return structured error when query fails", async () => {
+    const tool = createGRFlowControlTool(mockAdapter);
+    mockExecuteQuery.mockRejectedValue(new Error("Timeout"));
+
+    const result = (await tool.handler({}, {} as any)) as any;
+
+    expect(result.configuration).toEqual({});
+    expect(result.memberQueues).toEqual([]);
+    expect(result.isThrottling).toBe(false);
+    expect(result.error).toBe("Timeout");
+  });
+});

package/src/adapters/mysql/tools/cluster/__tests__/innodb-cluster.test.ts

@@ -125,6 +125,22 @@ describe("InnoDB Cluster Tools", () => {
   });
 
   describe("createClusterInstancesTool", () => {
+    it("should include primaryError when both queries fail", async () => {
+      mockAdapter.executeQuery
+        .mockRejectedValueOnce(new Error("Metadata query failed")) // Primary fails
+        .mockRejectedValueOnce(new Error("GR query also failed")); // Fallback fails
+
+      const tool = createClusterInstancesTool(
+        mockAdapter as unknown as MySQLAdapter,
+      );
+      const result = (await tool.handler({ limit: 10 }, mockContext)) as any;
+
+      expect(result.instances).toEqual([]);
+      expect(result.count).toBe(0);
+      expect(result.error).toBe("GR query also failed");
+      expect(result.primaryError).toBe("Metadata query failed");
+    });
+
     it("should fallback to GR members when InnoDB Cluster metadata query fails", async () => {
       mockAdapter.executeQuery
         .mockRejectedValueOnce(new Error("Table not found")) // First query fails
@@ -388,11 +404,36 @@ describe("InnoDB Cluster Tools", () => {
 
       expect(result.canSwitchover).toBe(false);
       expect(result.candidates).toHaveLength(0);
+      expect(result.currentPrimary).toBeDefined();
       expect(result.warning).toBe(
         "No online secondaries available for switchover.",
       );
     });
 
+    it("should return currentPrimary as null when no primary exists", async () => {
+      mockAdapter.executeQuery.mockResolvedValueOnce(
+        createMockQueryResult([
+          {
+            memberId: "uuid1",
+            host: "node1",
+            port: 3306,
+            state: "OFFLINE",
+            role: "SECONDARY",
+            version: "9.2.0",
+            txQueue: 0,
+            applierQueue: 0,
+          },
+        ]),
+      );
+
+      const tool = createClusterSwitchoverTool(
+        mockAdapter as unknown as MySQLAdapter,
+      );
+      const result = (await tool.handler({}, mockContext)) as any;
+
+      expect(result.currentPrimary).toBeNull();
+    });
+
     it("should recommend good switchover candidate", async () => {
       mockAdapter.executeQuery.mockResolvedValueOnce(
         createMockQueryResult([
@@ -431,4 +472,104 @@ describe("InnoDB Cluster Tools", () => {
       expect(result.warning).toBeUndefined();
     });
   });
+
+  describe("createClusterTopologyTool - error handling", () => {
+    it("should return structured error when first query fails", async () => {
+      mockAdapter.executeQuery.mockRejectedValue(
+        new Error("Connection refused"),
+      );
+
+      const tool = createClusterTopologyTool(
+        mockAdapter as unknown as MySQLAdapter,
+      );
+      const result = (await tool.handler({}, mockContext)) as any;
+
+      expect(result.topology).toEqual({
+        primary: [],
+        secondaries: [],
+        recovering: [],
+        offline: [],
+      });
+      expect(result.visualization).toBe("");
+      expect(result.totalMembers).toBe(0);
+      expect(result.onlineMembers).toBe(0);
+      expect(result.error).toBe("Connection refused");
+    });
+  });
+
+  describe("createClusterSwitchoverTool - error handling", () => {
+    it("should return structured error when query fails", async () => {
+      mockAdapter.executeQuery.mockRejectedValue(new Error("Access denied"));
+
+      const tool = createClusterSwitchoverTool(
+        mockAdapter as unknown as MySQLAdapter,
+      );
+      const result = (await tool.handler({}, mockContext)) as any;
+
+      expect(result.candidates).toEqual([]);
+      expect(result.canSwitchover).toBe(false);
+      expect(result.error).toBe("Access denied");
+    });
+  });
+
+  describe("Zod validation leak prevention", () => {
+    it("cluster_status should return structured error for invalid summary type", async () => {
+      const tool = createClusterStatusTool(
+        mockAdapter as unknown as MySQLAdapter,
+      );
+      const result = (await tool.handler(
+        { summary: "yes" },
+        mockContext,
+      )) as any;
+
+      expect(result.isInnoDBCluster).toBe(false);
+      expect(result.error).toBeDefined();
+      expect(result.error).toContain("expected boolean");
+    });
+
+    it("cluster_instances should return structured error for invalid limit type", async () => {
+      const tool = createClusterInstancesTool(
+        mockAdapter as unknown as MySQLAdapter,
+      );
+      const result = (await tool.handler({ limit: "abc" }, mockContext)) as any;
+
+      expect(result.instances).toEqual([]);
+      expect(result.count).toBe(0);
+      expect(result.error).toBeDefined();
+      expect(result.error).toContain("expected number");
+    });
+
+    it("cluster_instances should return structured error for negative limit", async () => {
+      const tool = createClusterInstancesTool(
+        mockAdapter as unknown as MySQLAdapter,
+      );
+      const result = (await tool.handler({ limit: -5 }, mockContext)) as any;
+
+      expect(result.instances).toEqual([]);
+      expect(result.count).toBe(0);
+      expect(result.error).toBeDefined();
+    });
+
+    it("cluster_instances should return structured error for float limit", async () => {
+      const tool = createClusterInstancesTool(
+        mockAdapter as unknown as MySQLAdapter,
+      );
+      const result = (await tool.handler({ limit: 0.5 }, mockContext)) as any;
+
+      expect(result.instances).toEqual([]);
+      expect(result.count).toBe(0);
+      expect(result.error).toBeDefined();
+    });
+
+    it("cluster_router_status should return structured error for invalid summary type", async () => {
+      const tool = createClusterRouterStatusTool(
+        mockAdapter as unknown as MySQLAdapter,
+      );
+      const result = (await tool.handler({ summary: 123 }, mockContext)) as any;
+
+      expect(result.available).toBe(false);
+      expect(result.error).toBeDefined();
+      expect(result.error).toContain("expected boolean");
+    });
+  });
 });

package/src/adapters/mysql/tools/cluster/group-replication.ts

@@ -41,18 +41,19 @@ export function createGRStatusTool(adapter: MySQLAdapter): ToolDefinition {
       idempotentHint: true,
     },
     handler: async (_params: unknown, _context: RequestContext) => {
-      // Check if GR is running
-      const pluginResult = await adapter.executeQuery(
-        "SELECT PLUGIN_STATUS FROM information_schema.PLUGINS WHERE PLUGIN_NAME = 'group_replication'",
-      );
-      if (pluginResult.rows?.[0]?.["PLUGIN_STATUS"] !== "ACTIVE") {
-        return {
-          enabled: false,
-          message: "Group Replication plugin is not active",
-        };
-      }
+      try {
+        // Check if GR is running
+        const pluginResult = await adapter.executeQuery(
+          "SELECT PLUGIN_STATUS FROM information_schema.PLUGINS WHERE PLUGIN_NAME = 'group_replication'",
+        );
+        if (pluginResult.rows?.[0]?.["PLUGIN_STATUS"] !== "ACTIVE") {
+          return {
+            enabled: false,
+            message: "Group Replication plugin is not active",
+          };
+        }
 
-      const statusResult = await adapter.executeQuery(`
+        const statusResult = await adapter.executeQuery(`
                 SELECT 
                     @@group_replication_group_name as groupName,
                     @@group_replication_single_primary_mode as singlePrimaryMode,
@@ -61,10 +62,10 @@ export function createGRStatusTool(adapter: MySQLAdapter): ToolDefinition {
                     @@group_replication_bootstrap_group as bootstrapGroup
             `);
 
-      const config = statusResult.rows?.[0];
+        const config = statusResult.rows?.[0];
 
-      // Get member status from performance_schema
-      const memberResult = await adapter.executeQuery(`
+        // Get member status from performance_schema
+        const memberResult = await adapter.executeQuery(`
                 SELECT 
                     CHANNEL_NAME,
                     MEMBER_ID,
@@ -76,35 +77,41 @@ export function createGRStatusTool(adapter: MySQLAdapter): ToolDefinition {
                 FROM performance_schema.replication_group_members
             `);
 
-      // Get local member info
-      const localResult = await adapter.executeQuery(`
+        // Get local member info
+        const localResult = await adapter.executeQuery(`
                 SELECT @@server_uuid as serverUuid
             `);
 
-      const localUuid = localResult.rows?.[0]?.["serverUuid"] as string;
-      const members = memberResult.rows ?? [];
-      const localMember = members.find((m) => m["MEMBER_ID"] === localUuid);
+        const localUuid = localResult.rows?.[0]?.["serverUuid"] as string;
+        const members = memberResult.rows ?? [];
+        const localMember = members.find((m) => m["MEMBER_ID"] === localUuid);
 
-      return {
-        enabled: members.length > 0,
-        groupName: config?.["groupName"] ?? null,
-        singlePrimaryMode: config?.["singlePrimaryMode"] === 1,
-        localAddress: config?.["localAddress"] ?? null,
-        localMember: localMember ?? null,
-        memberCount: members.length,
-        members: members.map((m) => {
-          const member = m;
-          return {
-            id: member["MEMBER_ID"],
-            host: member["MEMBER_HOST"],
-            port: member["MEMBER_PORT"],
-            state: member["MEMBER_STATE"],
-            role: member["MEMBER_ROLE"],
-            version: member["MEMBER_VERSION"],
-            isLocal: member["MEMBER_ID"] === localUuid,
-          };
-        }),
-      };
+        return {
+          enabled: members.length > 0,
+          groupName: config?.["groupName"] ?? null,
+          singlePrimaryMode: config?.["singlePrimaryMode"] === 1,
+          localAddress: config?.["localAddress"] ?? null,
+          localMember: localMember ?? null,
+          memberCount: members.length,
+          members: members.map((m) => {
+            const member = m;
+            return {
+              id: member["MEMBER_ID"],
+              host: member["MEMBER_HOST"],
+              port: member["MEMBER_PORT"],
+              state: member["MEMBER_STATE"],
+              role: member["MEMBER_ROLE"],
+              version: member["MEMBER_VERSION"],
+              isLocal: member["MEMBER_ID"] === localUuid,
+            };
+          }),
+        };
+      } catch (error) {
+        return {
+          enabled: false,
+          error: error instanceof Error ? error.message : String(error),
+        };
+      }
     },
   };
 }
@@ -126,21 +133,22 @@ export function createGRMembersTool(adapter: MySQLAdapter): ToolDefinition {
       idempotentHint: true,
     },
     handler: async (params: unknown, _context: RequestContext) => {
-      const { memberId } = MemberSchema.parse(params);
+      try {
+        const { memberId } = MemberSchema.parse(params);
 
-      // Check if GR is running
-      const pluginResult = await adapter.executeQuery(
-        "SELECT PLUGIN_STATUS FROM information_schema.PLUGINS WHERE PLUGIN_NAME = 'group_replication'",
-      );
-      if (pluginResult.rows?.[0]?.["PLUGIN_STATUS"] !== "ACTIVE") {
-        return {
-          members: [],
-          count: 0,
-          message: "Group Replication not active",
-        };
-      }
+        // Check if GR is running
+        const pluginResult = await adapter.executeQuery(
+          "SELECT PLUGIN_STATUS FROM information_schema.PLUGINS WHERE PLUGIN_NAME = 'group_replication'",
+        );
+        if (pluginResult.rows?.[0]?.["PLUGIN_STATUS"] !== "ACTIVE") {
+          return {
+            members: [],
+            count: 0,
+            message: "Group Replication not active",
+          };
+        }
 
-      let query = `
+        let query = `
                 SELECT 
                     m.MEMBER_ID as memberId,
                     m.MEMBER_HOST as host,
@@ -157,17 +165,24 @@ export function createGRMembersTool(adapter: MySQLAdapter): ToolDefinition {
                     ON m.MEMBER_ID = s.MEMBER_ID
             `;
 
-      const queryParams: unknown[] = [];
-      if (memberId) {
-        query += " WHERE m.MEMBER_ID = ?";
-        queryParams.push(memberId);
-      }
+        const queryParams: unknown[] = [];
+        if (memberId) {
+          query += " WHERE m.MEMBER_ID = ?";
+          queryParams.push(memberId);
+        }
 
-      const result = await adapter.executeQuery(query, queryParams);
-      return {
-        members: result.rows ?? [],
-        count: result.rows?.length ?? 0,
-      };
+        const result = await adapter.executeQuery(query, queryParams);
+        return {
+          members: result.rows ?? [],
+          count: result.rows?.length ?? 0,
+        };
+      } catch (error) {
+        return {
+          members: [],
+          count: 0,
+          error: error instanceof Error ? error.message : String(error),
+        };
+      }
     },
   };
 }
@@ -189,7 +204,8 @@ export function createGRPrimaryTool(adapter: MySQLAdapter): ToolDefinition {
       idempotentHint: true,
     },
     handler: async (_params: unknown, _context: RequestContext) => {
-      const result = await adapter.executeQuery(`
+      try {
+        const result = await adapter.executeQuery(`
                 SELECT 
                     MEMBER_ID as memberId,
                     MEMBER_HOST as host,
@@ -200,19 +216,25 @@ export function createGRPrimaryTool(adapter: MySQLAdapter): ToolDefinition {
                 WHERE MEMBER_ROLE = 'PRIMARY'
             `);
 
-      const primary = result.rows?.[0];
+        const primary = result.rows?.[0];
 
-      // Check if we are the primary
-      const localResult = await adapter.executeQuery(
-        "SELECT @@server_uuid as serverUuid",
-      );
-      const localUuid = localResult.rows?.[0]?.["serverUuid"];
+        // Check if we are the primary
+        const localResult = await adapter.executeQuery(
+          "SELECT @@server_uuid as serverUuid",
+        );
+        const localUuid = localResult.rows?.[0]?.["serverUuid"];
 
-      return {
-        primary: primary ?? null,
-        hasPrimary: !!primary,
-        isLocalPrimary: primary?.["memberId"] === localUuid,
-      };
+        return {
+          primary: primary ?? null,
+          hasPrimary: !!primary,
+          isLocalPrimary: primary?.["memberId"] === localUuid,
+        };
+      } catch (error) {
+        return {
+          hasPrimary: false,
+          error: error instanceof Error ? error.message : String(error),
+        };
+      }
     },
   };
 }
@@ -236,20 +258,21 @@ export function createGRTransactionsTool(
       idempotentHint: true,
     },
     handler: async (_params: unknown, _context: RequestContext) => {
-      // Check if GR is running
-      const pluginResult = await adapter.executeQuery(
-        "SELECT PLUGIN_STATUS FROM information_schema.PLUGINS WHERE PLUGIN_NAME = 'group_replication'",
-      );
-      if (pluginResult.rows?.[0]?.["PLUGIN_STATUS"] !== "ACTIVE") {
-        return {
-          memberStats: [],
-          gtid: { executed: "", purged: "" },
-          message: "Group Replication not active",
-        };
-      }
+      try {
+        // Check if GR is running
+        const pluginResult = await adapter.executeQuery(
+          "SELECT PLUGIN_STATUS FROM information_schema.PLUGINS WHERE PLUGIN_NAME = 'group_replication'",
+        );
+        if (pluginResult.rows?.[0]?.["PLUGIN_STATUS"] !== "ACTIVE") {
+          return {
+            memberStats: [],
+            gtid: { executed: "", purged: "" },
+            message: "Group Replication not active",
+          };
+        }
 
-      // Get transaction statistics
-      const statsResult = await adapter.executeQuery(`
+        // Get transaction statistics
+        const statsResult = await adapter.executeQuery(`
                 SELECT 
                     MEMBER_ID as memberId,
                     COUNT_TRANSACTIONS_IN_QUEUE as txInQueue,
@@ -263,22 +286,29 @@ export function createGRTransactionsTool(
                 FROM performance_schema.replication_group_member_stats
             `);
 
-      // Get GTID info
-      const gtidResult = await adapter.executeQuery(`
+        // Get GTID info
+        const gtidResult = await adapter.executeQuery(`
                 SELECT 
                     @@gtid_executed as gtidExecuted,
                     @@gtid_purged as gtidPurged
             `);
 
-      const gtid = gtidResult.rows?.[0];
+        const gtid = gtidResult.rows?.[0];
 
-      return {
-        memberStats: statsResult.rows ?? [],
-        gtid: {
-          executed: gtid?.["gtidExecuted"] ?? "",
-          purged: gtid?.["gtidPurged"] ?? "",
-        },
-      };
+        return {
+          memberStats: statsResult.rows ?? [],
+          gtid: {
+            executed: gtid?.["gtidExecuted"] ?? "",
+            purged: gtid?.["gtidPurged"] ?? "",
+          },
+        };
+      } catch (error) {
+        return {
+          memberStats: [],
+          gtid: { executed: "", purged: "" },
+          error: error instanceof Error ? error.message : String(error),
+        };
+      }
     },
   };
 }
@@ -300,21 +330,22 @@ export function createGRFlowControlTool(adapter: MySQLAdapter): ToolDefinition {
       idempotentHint: true,
     },
     handler: async (_params: unknown, _context: RequestContext) => {
-      // Check if GR is running
-      const pluginResult = await adapter.executeQuery(
-        "SELECT PLUGIN_STATUS FROM information_schema.PLUGINS WHERE PLUGIN_NAME = 'group_replication'",
-      );
-      if (pluginResult.rows?.[0]?.["PLUGIN_STATUS"] !== "ACTIVE") {
-        return {
-          configuration: {},
-          memberQueues: [],
-          isThrottling: false,
-          message: "Group Replication not active",
-        };
-      }
+      try {
+        // Check if GR is running
+        const pluginResult = await adapter.executeQuery(
+          "SELECT PLUGIN_STATUS FROM information_schema.PLUGINS WHERE PLUGIN_NAME = 'group_replication'",
+        );
+        if (pluginResult.rows?.[0]?.["PLUGIN_STATUS"] !== "ACTIVE") {
+          return {
+            configuration: {},
+            memberQueues: [],
+            isThrottling: false,
+            message: "Group Replication not active",
+          };
+        }
 
-      // Get flow control configuration
-      const configResult = await adapter.executeQuery(`
+        // Get flow control configuration
+        const configResult = await adapter.executeQuery(`
                 SELECT 
                     @@group_replication_flow_control_mode as flowControlMode,
                     @@group_replication_flow_control_certifier_threshold as certifierThreshold,
@@ -324,10 +355,10 @@ export function createGRFlowControlTool(adapter: MySQLAdapter): ToolDefinition {
                     @@group_replication_flow_control_max_quota as maxQuota
             `);
 
-      const config = configResult.rows?.[0];
+        const config = configResult.rows?.[0];
 
-      // Get current queue depths
-      const queueResult = await adapter.executeQuery(`
+        // Get current queue depths
+        const queueResult = await adapter.executeQuery(`
                 SELECT 
                     MEMBER_ID as memberId,
                     COUNT_TRANSACTIONS_IN_QUEUE as certifyQueue,
@@ -335,25 +366,34 @@ export function createGRFlowControlTool(adapter: MySQLAdapter): ToolDefinition {
                 FROM performance_schema.replication_group_member_stats
             `);
 
-      // Determine if flow control is active
-      const isThrottling = (queueResult.rows ?? []).some((row) => {
-        const r = row;
-        const certQueue = r["certifyQueue"] as number;
-        const appQueue = r["applierQueue"] as number;
-        const certThreshold =
-          (config?.["certifierThreshold"] as number) ?? 25000;
-        const appThreshold = (config?.["applierThreshold"] as number) ?? 25000;
-        return certQueue > certThreshold || appQueue > appThreshold;
-      });
+        // Determine if flow control is active
+        const isThrottling = (queueResult.rows ?? []).some((row) => {
+          const r = row;
+          const certQueue = r["certifyQueue"] as number;
+          const appQueue = r["applierQueue"] as number;
+          const certThreshold =
+            (config?.["certifierThreshold"] as number) ?? 25000;
+          const appThreshold =
+            (config?.["applierThreshold"] as number) ?? 25000;
+          return certQueue > certThreshold || appQueue > appThreshold;
+        });
 
-      return {
-        configuration: config ?? {},
-        memberQueues: queueResult.rows ?? [],
-        isThrottling,
-        recommendation: isThrottling
-          ? "Flow control is active. Consider investigating slow members or adjusting thresholds."
-          : "Flow control is not currently throttling.",
-      };
+        return {
+          configuration: config ?? {},
+          memberQueues: queueResult.rows ?? [],
+          isThrottling,
+          recommendation: isThrottling
+            ? "Flow control is active. Consider investigating slow members or adjusting thresholds."
+            : "Flow control is not currently throttling.",
+        };
+      } catch (error) {
+        return {
+          configuration: {},
+          memberQueues: [],
+          isThrottling: false,
+          error: error instanceof Error ? error.message : String(error),
+        };
+      }
     },
   };
 }