@neverinfamous/mysql-mcp 2.3.0 → 3.0.0

package/src/adapters/mysql/tools/__tests__/events.test.ts

@@ -483,49 +483,117 @@ describe("Event Create Advanced", () => {
     expect(call).toContain("DISABLE");
   });
 
-  it("should throw error for invalid event name", async () => {
+  it("should return structured error for invalid event name", async () => {
     const tool = tools.find((t) => t.name === "mysql_event_create")!;
 
-    await expect(
-      tool.handler(
-        {
-          name: "123-invalid",
-          schedule: { type: "ONE TIME", executeAt: "2024-12-31 23:59:59" },
-          body: "SELECT 1",
-        },
-        mockContext,
-      ),
-    ).rejects.toThrow("Invalid event name");
+    const result = await tool.handler(
+      {
+        name: "123-invalid",
+        schedule: { type: "ONE TIME", executeAt: "2024-12-31 23:59:59" },
+        body: "SELECT 1",
+      },
+      mockContext,
+    );
+
+    expect(result).toEqual({ success: false, error: "Invalid event name" });
   });
 
-  it("should throw error when executeAt is missing for ONE TIME events", async () => {
+  it("should return structured error when executeAt is missing for ONE TIME events", async () => {
     const tool = tools.find((t) => t.name === "mysql_event_create")!;
 
-    await expect(
-      tool.handler(
-        {
-          name: "bad_event",
-          schedule: { type: "ONE TIME" },
-          body: "SELECT 1",
-        },
-        mockContext,
-      ),
-    ).rejects.toThrow("executeAt is required");
+    const result = await tool.handler(
+      {
+        name: "bad_event",
+        schedule: { type: "ONE TIME" },
+        body: "SELECT 1",
+      },
+      mockContext,
+    );
+
+    expect(result).toEqual({
+      success: false,
+      error: "executeAt is required for ONE TIME events",
+    });
   });
 
-  it("should throw error when interval is missing for RECURRING events", async () => {
+  it("should return structured error when interval is missing for RECURRING events", async () => {
     const tool = tools.find((t) => t.name === "mysql_event_create")!;
 
-    await expect(
-      tool.handler(
-        {
-          name: "bad_recurring",
-          schedule: { type: "RECURRING" },
-          body: "SELECT 1",
+    const result = await tool.handler(
+      {
+        name: "bad_recurring",
+        schedule: { type: "RECURRING" },
+        body: "SELECT 1",
+      },
+      mockContext,
+    );
+
+    expect(result).toEqual({
+      success: false,
+      error: "interval and intervalUnit are required for RECURRING events",
+    });
+  });
+
+  it("should return structured error for invalid schedule type on create", async () => {
+    const tool = tools.find((t) => t.name === "mysql_event_create")!;
+
+    const result = await tool.handler(
+      {
+        name: "my_event",
+        schedule: { type: "INVALID_TYPE" },
+        body: "SELECT 1",
+      },
+      mockContext,
+    );
+
+    expect(result).toHaveProperty("success", false);
+    expect(result).toHaveProperty("error");
+    expect((result as { error: string }).error).toContain(
+      "Invalid schedule type",
+    );
+  });
+
+  it("should return structured error for invalid onCompletion on create", async () => {
+    const tool = tools.find((t) => t.name === "mysql_event_create")!;
+
+    const result = await tool.handler(
+      {
+        name: "my_event",
+        schedule: { type: "ONE TIME", executeAt: "2024-12-31 23:59:59" },
+        body: "SELECT 1",
+        onCompletion: "INVALID_VALUE",
+      },
+      mockContext,
+    );
+
+    expect(result).toHaveProperty("success", false);
+    expect(result).toHaveProperty("error");
+    expect((result as { error: string }).error).toContain(
+      "Invalid onCompletion",
+    );
+  });
+
+  it("should return structured error for invalid intervalUnit on create", async () => {
+    const tool = tools.find((t) => t.name === "mysql_event_create")!;
+
+    const result = await tool.handler(
+      {
+        name: "my_event",
+        schedule: {
+          type: "RECURRING",
+          interval: 1,
+          intervalUnit: "INVALID_UNIT",
         },
-        mockContext,
-      ),
-    ).rejects.toThrow("interval and intervalUnit are required");
+        body: "SELECT 1",
+      },
+      mockContext,
+    );
+
+    expect(result).toHaveProperty("success", false);
+    expect(result).toHaveProperty("error");
+    expect((result as { error: string }).error).toContain(
+      "Invalid intervalUnit",
+    );
   });
 });
 
@@ -629,73 +697,118 @@ describe("Event Alter Advanced", () => {
     expect(call).toContain("COMMENT 'Updated comment'");
   });
 
-  it("should throw error for invalid event name", async () => {
+  it("should return structured error for invalid event name", async () => {
     const tool = tools.find((t) => t.name === "mysql_event_alter")!;
 
-    await expect(
-      tool.handler(
-        {
-          name: "invalid-name",
-          enabled: true,
-        },
-        mockContext,
-      ),
-    ).rejects.toThrow("Invalid event name");
+    const result = await tool.handler(
+      {
+        name: "invalid-name",
+        enabled: true,
+      },
+      mockContext,
+    );
+
+    expect(result).toEqual({ success: false, error: "Invalid event name" });
   });
 
-  it("should throw error for invalid new event name", async () => {
+  it("should return structured error for invalid new event name", async () => {
     const tool = tools.find((t) => t.name === "mysql_event_alter")!;
 
-    await expect(
-      tool.handler(
-        {
-          name: "valid_name",
-          newName: "123-invalid",
-        },
-        mockContext,
-      ),
-    ).rejects.toThrow("Invalid new event name");
+    const result = await tool.handler(
+      {
+        name: "valid_name",
+        newName: "123-invalid",
+      },
+      mockContext,
+    );
+
+    expect(result).toEqual({ success: false, error: "Invalid new event name" });
   });
 
-  it("should throw error when no modifications specified", async () => {
+  it("should return structured error when no modifications specified", async () => {
     const tool = tools.find((t) => t.name === "mysql_event_alter")!;
 
-    await expect(
-      tool.handler(
-        {
-          name: "my_event",
-        },
-        mockContext,
-      ),
-    ).rejects.toThrow("No modifications specified");
+    const result = await tool.handler(
+      {
+        name: "my_event",
+      },
+      mockContext,
+    );
+
+    expect(result).toEqual({
+      success: false,
+      error: "No modifications specified",
+    });
   });
 
-  it("should throw error when executeAt missing for ONE TIME alter", async () => {
+  it("should return structured error when executeAt missing for ONE TIME alter", async () => {
     const tool = tools.find((t) => t.name === "mysql_event_alter")!;
 
-    await expect(
-      tool.handler(
-        {
-          name: "my_event",
-          schedule: { type: "ONE TIME" },
-        },
-        mockContext,
-      ),
-    ).rejects.toThrow("executeAt is required");
+    const result = await tool.handler(
+      {
+        name: "my_event",
+        schedule: { type: "ONE TIME" },
+      },
+      mockContext,
+    );
+
+    expect(result).toEqual({
+      success: false,
+      error: "executeAt is required for ONE TIME events",
+    });
   });
 
-  it("should throw error when interval missing for RECURRING alter", async () => {
+  it("should return structured error when interval missing for RECURRING alter", async () => {
     const tool = tools.find((t) => t.name === "mysql_event_alter")!;
 
-    await expect(
-      tool.handler(
-        {
-          name: "my_event",
-          schedule: { type: "RECURRING" },
-        },
-        mockContext,
-      ),
-    ).rejects.toThrow("interval and intervalUnit are required");
+    const result = await tool.handler(
+      {
+        name: "my_event",
+        schedule: { type: "RECURRING" },
+      },
+      mockContext,
+    );
+
+    expect(result).toEqual({
+      success: false,
+      error: "interval and intervalUnit are required for RECURRING events",
+    });
+  });
+
+  it("should return structured error for invalid onCompletion on alter", async () => {
+    const tool = tools.find((t) => t.name === "mysql_event_alter")!;
+
+    const result = await tool.handler(
+      {
+        name: "my_event",
+        onCompletion: "INVALID_VALUE",
+      },
+      mockContext,
+    );
+
+    expect(result).toHaveProperty("success", false);
+    expect(result).toHaveProperty("error");
+    expect((result as { error: string }).error).toContain(
+      "Invalid onCompletion",
+    );
+  });
+
+  it("should return structured error for invalid schedule type on alter", async () => {
+    const tool = tools.find((t) => t.name === "mysql_event_alter")!;
+
+    const result = await tool.handler(
+      {
+        name: "my_event",
+        schedule: { type: "INVALID_TYPE" },
+      },
+      mockContext,
+    );
+
+    expect(result).toHaveProperty("success", false);
+    expect(result).toHaveProperty("error");
+    expect((result as { error: string }).error).toContain(
+      "Invalid schedule type",
+    );
   });
 });
 
@@ -711,17 +824,17 @@ describe("Event Drop Advanced", () => {
     mockContext = createMockRequestContext();
   });
 
-  it("should throw error for invalid event name", async () => {
+  it("should return structured error for invalid event name", async () => {
     const tool = tools.find((t) => t.name === "mysql_event_drop")!;
 
-    await expect(
-      tool.handler(
-        {
-          name: "invalid-event-name",
-        },
-        mockContext,
-      ),
-    ).rejects.toThrow("Invalid event name");
+    const result = await tool.handler(
+      {
+        name: "invalid-event-name",
+      },
+      mockContext,
+    );
+
+    expect(result).toEqual({ success: false, error: "Invalid event name" });
   });
 
   it("should drop without IF EXISTS when ifExists is false", async () => {
@@ -771,7 +884,7 @@ describe("Event Graceful Error Handling", () => {
 
     expect(result).toEqual({
       success: false,
-      reason: "Event 'my_event' already exists",
+      error: "Event already exists",
     });
   });
 
@@ -792,7 +905,7 @@ describe("Event Graceful Error Handling", () => {
 
     expect(result).toEqual({
       success: false,
-      reason: "Event 'ghost_event' does not exist",
+      error: "Event does not exist",
     });
   });
 
@@ -813,23 +926,88 @@ describe("Event Graceful Error Handling", () => {
 
     expect(result).toEqual({
       success: false,
-      reason: "Event 'ghost_event' does not exist",
+      error: "Event does not exist",
     });
   });
 
-  it("should rethrow unexpected errors from create", async () => {
+  it("should return structured error for unexpected errors from create", async () => {
     mockAdapter.executeQuery.mockRejectedValue(new Error("Connection lost"));
 
     const tool = tools.find((t) => t.name === "mysql_event_create")!;
-    await expect(
-      tool.handler(
-        {
-          name: "my_event",
-          schedule: { type: "ONE TIME", executeAt: "2024-12-31 23:59:59" },
-          body: "SELECT 1",
-        },
-        mockContext,
+    const result = await tool.handler(
+      {
+        name: "my_event",
+        schedule: { type: "ONE TIME", executeAt: "2024-12-31 23:59:59" },
+        body: "SELECT 1",
+      },
+      mockContext,
+    );
+
+    expect(result).toEqual({ success: false, error: "Connection lost" });
+  });
+
+  it("should strip error prefix from create error messages", async () => {
+    mockAdapter.executeQuery.mockRejectedValue(
+      new Error(
+        "Query failed: Execute failed: You have an error in your SQL syntax",
       ),
-    ).rejects.toThrow("Connection lost");
+    );
+
+    const tool = tools.find((t) => t.name === "mysql_event_create")!;
+    const result = await tool.handler(
+      {
+        name: "my_event",
+        schedule: { type: "ONE TIME", executeAt: "2024-12-31 23:59:59" },
+        body: "SELECTT * FROMM",
+      },
+      mockContext,
+    );
+
+    expect(result).toEqual({
+      success: false,
+      error: "You have an error in your SQL syntax",
+    });
+  });
+
+  it("should return structured error when event_list query fails", async () => {
+    mockAdapter.executeQuery.mockRejectedValue(
+      new Error("Connection lost during query"),
+    );
+
+    const tool = tools.find((t) => t.name === "mysql_event_list")!;
+    const result = await tool.handler({}, mockContext);
+
+    expect(result).toEqual({
+      success: false,
+      error: "Connection lost during query",
+    });
+  });
+
+  it("should return structured error when event_status query fails", async () => {
+    mockAdapter.executeQuery.mockRejectedValue(
+      new Error("Connection lost during query"),
+    );
+
+    const tool = tools.find((t) => t.name === "mysql_event_status")!;
+    const result = await tool.handler({ name: "test_event" }, mockContext);
+
+    expect(result).toEqual({
+      success: false,
+      error: "Connection lost during query",
+    });
+  });
+
+  it("should return structured error when scheduler_status query fails", async () => {
+    mockAdapter.executeQuery.mockRejectedValue(
+      new Error("Connection lost during query"),
+    );
+
+    const tool = tools.find((t) => t.name === "mysql_scheduler_status")!;
+    const result = await tool.handler({}, mockContext);
+
+    expect(result).toEqual({
+      success: false,
+      error: "Connection lost during query",
+    });
   });
 });

package/src/adapters/mysql/tools/__tests__/proxysql.test.ts

@@ -34,8 +34,8 @@ describe("getProxySQLTools", () => {
     );
   });
 
-  it("should return 12 proxysql tools", () => {
-    expect(tools).toHaveLength(12);
+  it("should return 11 proxysql tools", () => {
+    expect(tools).toHaveLength(11);
   });
 
   it("should have proxysql group for all tools", () => {
@@ -60,7 +60,6 @@ describe("getProxySQLTools", () => {
     const toolNames = tools.map((t) => t.name);
     expect(toolNames).toContain("proxysql_status");
     expect(toolNames).toContain("proxysql_servers");
-    expect(toolNames).toContain("proxysql_hostgroups");
     expect(toolNames).toContain("proxysql_query_rules");
     expect(toolNames).toContain("proxysql_query_digest");
     expect(toolNames).toContain("proxysql_connection_pool");
@@ -313,26 +312,16 @@ describe("Handler Execution", () => {
       );
       expect(result).toHaveProperty("count", 1);
     });
-  });
-
-  describe("proxysql_hostgroups", () => {
-    it("should return connection pool stats", async () => {
-      const mockPools = [
-        { hostgroup: 1, srv_host: "mysql1", ConnUsed: 5, ConnFree: 10 },
-      ];
-      mockQuery.mockResolvedValue([mockPools]);
 
-      const tool = tools.find((t) => t.name === "proxysql_hostgroups")!;
-      const result = await tool.handler({}, mockContext);
+    it("should return structured error for negative hostgroup_id", async () => {
+      const tool = tools.find((t) => t.name === "proxysql_servers")!;
+      const result = (await tool.handler(
+        { hostgroup_id: -1 },
+        mockContext,
+      )) as { success: boolean; error: string };
 
-      expect(mockQuery).toHaveBeenCalledWith(
-        "SELECT * FROM stats_mysql_connection_pool",
-      );
-      expect(result).toEqual({
-        success: true,
-        hostgroups: mockPools,
-        count: 1,
-      });
+      expect(result.success).toBe(false);
+      expect(result.error).toBeDefined();
     });
   });
 
@@ -360,6 +349,17 @@ describe("Handler Execution", () => {
         "SELECT * FROM mysql_query_rules LIMIT 10",
       );
     });
+
+    it("should return structured error for negative limit", async () => {
+      const tool = tools.find((t) => t.name === "proxysql_query_rules")!;
+      const result = (await tool.handler({ limit: -1 }, mockContext)) as {
+        success: boolean;
+        error: string;
+      };
+
+      expect(result.success).toBe(false);
+      expect(result.error).toBeDefined();
+    });
   });
 
   describe("proxysql_query_digest", () => {
@@ -393,6 +393,17 @@ describe("Handler Execution", () => {
         expect.stringContaining("LIMIT 25"),
       );
     });
+
+    it("should return structured error for negative limit", async () => {
+      const tool = tools.find((t) => t.name === "proxysql_query_digest")!;
+      const result = (await tool.handler({ limit: -1 }, mockContext)) as {
+        success: boolean;
+        error: string;
+      };
+
+      expect(result.success).toBe(false);
+      expect(result.error).toBeDefined();
+    });
   });
 
   describe("proxysql_connection_pool", () => {
@@ -419,6 +430,17 @@ describe("Handler Execution", () => {
         "SELECT * FROM stats_mysql_connection_pool WHERE hostgroup = 2",
       );
     });
+
+    it("should return structured error for negative hostgroup_id", async () => {
+      const tool = tools.find((t) => t.name === "proxysql_connection_pool")!;
+      const result = (await tool.handler(
+        { hostgroup_id: -1 },
+        mockContext,
+      )) as { success: boolean; error: string };
+
+      expect(result.success).toBe(false);
+      expect(result.error).toBeDefined();
+    });
   });
 
   describe("proxysql_users", () => {
@@ -557,6 +579,28 @@ describe("Handler Execution", () => {
       // totalVarsAvailable should reflect total count
       expect(result.totalVarsAvailable).toBe(4);
     });
+
+    it("should return structured error for negative limit", async () => {
+      const tool = tools.find((t) => t.name === "proxysql_global_variables")!;
+      const result = (await tool.handler({ limit: -1 }, mockContext)) as {
+        success: boolean;
+        error: string;
+      };
+
+      expect(result.success).toBe(false);
+      expect(result.error).toBeDefined();
+    });
+
+    it("should return structured error for unsafe like pattern", async () => {
+      const tool = tools.find((t) => t.name === "proxysql_global_variables")!;
+      const result = (await tool.handler(
+        { like: "'; DROP TABLE --" },
+        mockContext,
+      )) as { success: boolean; error: string };
+
+      expect(result.success).toBe(false);
+      expect(result.error).toContain("Invalid like pattern");
+    });
   });
 
   describe("proxysql_memory_stats", () => {
@@ -633,26 +677,82 @@ describe("Connection Error Handling", () => {
     mockContext = createMockRequestContext();
   });
 
-  it("should propagate connection errors", async () => {
+  it("should return structured error on connection failure", async () => {
     mockCreateConnection.mockRejectedValue(new Error("Connection refused"));
 
     const tool = tools.find((t) => t.name === "proxysql_status")!;
+    const result = (await tool.handler({}, mockContext)) as {
+      success: boolean;
+      error: string;
+    };
 
-    await expect(tool.handler({}, mockContext)).rejects.toThrow(
-      "Connection refused",
-    );
+    expect(result.success).toBe(false);
+    expect(result.error).toContain("Connection refused");
   });
 
-  it("should propagate query errors", async () => {
+  it("should return structured error on query failure", async () => {
     mockCreateConnection.mockResolvedValue({
       query: vi.fn().mockRejectedValue(new Error("Access denied")),
       end: mockEnd,
     });
 
     const tool = tools.find((t) => t.name === "proxysql_status")!;
+    const result = (await tool.handler({}, mockContext)) as {
+      success: boolean;
+      error: string;
+    };
+
+    expect(result.success).toBe(false);
+    expect(result.error).toContain("Access denied");
+  });
+});
 
-    await expect(tool.handler({}, mockContext)).rejects.toThrow(
-      "Access denied",
+describe("Crash Tests (all 12 handlers)", () => {
+  let tools: ReturnType<typeof getProxySQLTools>;
+  let mockContext: ReturnType<typeof createMockRequestContext>;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    tools = getProxySQLTools(
+      createMockMySQLAdapter() as unknown as MySQLAdapter,
     );
+    mockContext = createMockRequestContext();
+
+    // All tools will fail on query
+    mockCreateConnection.mockResolvedValue({
+      query: vi.fn().mockRejectedValue(new Error("ProxySQL unavailable")),
+      end: mockEnd,
+    });
   });
+
+  const toolNames = [
+    "proxysql_status",
+    "proxysql_runtime_status",
+    "proxysql_servers",
+    "proxysql_query_rules",
+    "proxysql_query_digest",
+    "proxysql_connection_pool",
+    "proxysql_users",
+    "proxysql_global_variables",
+    "proxysql_memory_stats",
+    "proxysql_commands",
+    "proxysql_process_list",
+  ];
+
+  for (const toolName of toolNames) {
+    it(`${toolName} should return { success: false, error } on query failure`, async () => {
+      const tool = tools.find((t) => t.name === toolName)!;
+      const params =
+        toolName === "proxysql_commands"
+          ? { command: "LOAD MYSQL USERS TO RUNTIME" }
+          : {};
+      const result = (await tool.handler(params, mockContext)) as {
+        success: boolean;
+        error: string;
+      };
+
+      expect(result.success).toBe(false);
+      expect(result.error).toContain("ProxySQL unavailable");
+    });
+  }
 });