@neverinfamous/mysql-mcp 2.3.1 → 3.0.0

package/src/adapters/mysql/tools/admin/__tests__/backup.test.ts

@@ -172,12 +172,13 @@ describe("Admin Backup Tools", () => {
         mockAdapter as unknown as MySQLAdapter,
       );
 
-      await expect(
-        tool.handler(
-          { table: "users; DROP TABLE users;--", format: "SQL" },
-          mockContext,
-        ),
-      ).rejects.toThrow();
+      const result = (await tool.handler(
+        { table: "users; DROP TABLE users;--", format: "SQL" },
+        mockContext,
+      )) as { success: boolean; error: string };
+
+      expect(result.success).toBe(false);
+      expect(result.error).toContain("Invalid table name");
     });
 
     it("should validate WHERE clause for SQL injection", async () => {
@@ -185,16 +186,17 @@ describe("Admin Backup Tools", () => {
         mockAdapter as unknown as MySQLAdapter,
       );
 
-      await expect(
-        tool.handler(
-          {
-            table: "users",
-            format: "SQL",
-            where: "1=1; DELETE FROM users;--",
-          },
-          mockContext,
-        ),
-      ).rejects.toThrow();
+      const result = (await tool.handler(
+        {
+          table: "users",
+          format: "SQL",
+          where: "1=1; DELETE FROM users;--",
+        },
+        mockContext,
+      )) as { success: boolean; error: string };
+
+      expect(result.success).toBe(false);
+      expect(result.error).toContain("dangerous SQL patterns");
     });
 
     it("should return exists: false for non-existent table", async () => {
@@ -249,6 +251,106 @@ describe("Admin Backup Tools", () => {
       expect(result.sql).toContain("(`id`, `email`, `created_at`)");
       expect(result.sql).toContain("VALUES");
     });
+
+    it("should return structured error for Zod validation failures", async () => {
+      const tool = createExportTableTool(
+        mockAdapter as unknown as MySQLAdapter,
+      );
+      const result = (await tool.handler(
+        { table: "users", limit: -1 },
+        mockContext,
+      )) as { success: boolean; error: string };
+
+      expect(result.success).toBe(false);
+      expect(result.error).toBeDefined();
+    });
+
+    it("should return structured error for limit: 0", async () => {
+      const tool = createExportTableTool(
+        mockAdapter as unknown as MySQLAdapter,
+      );
+      const result = (await tool.handler(
+        { table: "users", limit: 0 },
+        mockContext,
+      )) as { success: boolean; error: string };
+
+      expect(result.success).toBe(false);
+      expect(result.error).toBeDefined();
+    });
+
+    it("should batch rows into multi-row INSERT statements", async () => {
+      mockAdapter.executeReadQuery.mockResolvedValue(
+        createMockQueryResult([
+          { id: 1, name: "Alice" },
+          { id: 2, name: "Bob" },
+          { id: 3, name: "Charlie" },
+          { id: 4, name: "Diana" },
+        ]),
+      );
+
+      const tool = createExportTableTool(
+        mockAdapter as unknown as MySQLAdapter,
+      );
+      const result = (await tool.handler(
+        { table: "users", format: "SQL", batch: 2 },
+        mockContext,
+      )) as { sql: string; rowCount: number };
+
+      expect(result.rowCount).toBe(4);
+      const statements = result.sql.split("\n");
+      expect(statements).toHaveLength(2);
+      // Each statement should have 2 value groups
+      expect(statements[0]).toContain("VALUES (1, 'Alice'), (2, 'Bob')");
+      expect(statements[1]).toContain("VALUES (3, 'Charlie'), (4, 'Diana')");
+    });
+
+    it("should handle batch larger than row count", async () => {
+      mockAdapter.executeReadQuery.mockResolvedValue(
+        createMockQueryResult([
+          { id: 1, name: "Alice" },
+          { id: 2, name: "Bob" },
+          { id: 3, name: "Charlie" },
+        ]),
+      );
+
+      const tool = createExportTableTool(
+        mockAdapter as unknown as MySQLAdapter,
+      );
+      const result = (await tool.handler(
+        { table: "users", format: "SQL", batch: 10 },
+        mockContext,
+      )) as { sql: string; rowCount: number };
+
+      expect(result.rowCount).toBe(3);
+      const statements = result.sql.split("\n");
+      expect(statements).toHaveLength(1);
+      expect(statements[0]).toContain(
+        "VALUES (1, 'Alice'), (2, 'Bob'), (3, 'Charlie')",
+      );
+    });
+
+    it("should default to batch: 1 producing individual INSERT statements", async () => {
+      mockAdapter.executeReadQuery.mockResolvedValue(
+        createMockQueryResult([
+          { id: 1, name: "Alice" },
+          { id: 2, name: "Bob" },
+        ]),
+      );
+
+      const tool = createExportTableTool(
+        mockAdapter as unknown as MySQLAdapter,
+      );
+      const result = (await tool.handler(
+        { table: "users", format: "SQL" },
+        mockContext,
+      )) as { sql: string; rowCount: number };
+
+      expect(result.rowCount).toBe(2);
+      const statements = result.sql.split("\n");
+      expect(statements).toHaveLength(2);
+      expect(statements[0]).toContain("VALUES (1, 'Alice');");
+      expect(statements[1]).toContain("VALUES (2, 'Bob');");
+    });
   });
 
   describe("createImportDataTool", () => {
@@ -324,15 +426,16 @@ describe("Admin Backup Tools", () => {
     it("should validate table name for SQL injection", async () => {
       const tool = createImportDataTool(mockAdapter as unknown as MySQLAdapter);
 
-      await expect(
-        tool.handler(
-          {
-            table: "users; DROP TABLE users;--",
-            data: [{ name: "test" }],
-          },
-          mockContext,
-        ),
-      ).rejects.toThrow();
+      const result = (await tool.handler(
+        {
+          table: "users; DROP TABLE users;--",
+          data: [{ name: "test" }],
+        },
+        mockContext,
+      )) as { success: boolean; error: string };
+
+      expect(result.success).toBe(false);
+      expect(result.error).toContain("Invalid table name");
     });
 
     it("should handle various data types", async () => {
@@ -426,6 +529,17 @@ describe("Admin Backup Tools", () => {
       expect(result.error).toContain("Unknown column");
       expect(result.rowsInserted).toBe(0);
     });
+
+    it("should return structured error for Zod validation failures", async () => {
+      const tool = createImportDataTool(mockAdapter as unknown as MySQLAdapter);
+      const result = (await tool.handler(
+        { data: [{ name: "test" }] },
+        mockContext,
+      )) as { success: boolean; error: string };
+
+      expect(result.success).toBe(false);
+      expect(result.error).toBeDefined();
+    });
   });
 
   describe("createCreateDumpTool", () => {
@@ -544,6 +658,21 @@ describe("Admin Backup Tools", () => {
 
       expect(result.command).toBeDefined();
     });
+
+    it("should return structured error on query failure", async () => {
+      mockAdapter.executeReadQuery.mockRejectedValue(
+        new Error("Connection lost"),
+      );
+
+      const tool = createCreateDumpTool(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("Connection lost");
+    });
   });
 
   describe("createRestoreDumpTool", () => {
@@ -636,5 +765,22 @@ describe("Admin Backup Tools", () => {
 
       expect(result.command).toBeDefined();
     });
+
+    it("should return structured error on query failure", async () => {
+      mockAdapter.executeReadQuery.mockRejectedValue(
+        new Error("Connection lost"),
+      );
+
+      const tool = createRestoreDumpTool(
+        mockAdapter as unknown as MySQLAdapter,
+      );
+      const result = (await tool.handler(
+        { filename: "backup.sql" },
+        mockContext,
+      )) as { success: boolean; error: string };
+
+      expect(result.success).toBe(false);
+      expect(result.error).toContain("Connection lost");
+    });
   });
 });

package/src/adapters/mysql/tools/admin/__tests__/maintenance.test.ts

@@ -241,6 +241,18 @@ describe("Admin Maintenance Tools", () => {
       expect(result.results).toEqual([]);
       expect(result.rowCount).toBe(0);
     });
+
+    it("should return structured error for invalid option value", async () => {
+      const tool = createCheckTableTool(mockAdapter as unknown as MySQLAdapter);
+      const result = await tool.handler(
+        { tables: ["users"], option: "INVALID_OPTION" },
+        mockContext,
+      );
+
+      expect(result).toHaveProperty("success", false);
+      expect(result).toHaveProperty("error");
+      expect(typeof (result as { error: string }).error).toBe("string");
+    });
   });
 
   describe("createRepairTableTool", () => {
@@ -492,13 +504,172 @@ describe("Admin Maintenance Tools", () => {
       });
     });
 
-    it("should rethrow non-thread-id errors", async () => {
+    it("should return structured error for non-thread-id errors", async () => {
       mockAdapter.executeQuery.mockRejectedValue(new Error("Connection lost"));
 
       const tool = createKillQueryTool(mockAdapter as unknown as MySQLAdapter);
-      await expect(
-        tool.handler({ processId: 123 }, mockContext),
-      ).rejects.toThrow("Connection lost");
+      const result = await tool.handler({ processId: 123 }, mockContext);
+
+      expect(result).toEqual({ success: false, error: "Connection lost" });
+    });
+  });
+
+  describe("DDL handler error handling", () => {
+    it("mysql_optimize_table should return structured error on adapter failure", async () => {
+      mockAdapter.executeQuery.mockRejectedValue(
+        new Error("Table storage engine mismatch"),
+      );
+
+      const tool = createOptimizeTableTool(
+        mockAdapter as unknown as MySQLAdapter,
+      );
+      const result = await tool.handler({ tables: ["users"] }, mockContext);
+
+      expect(result).toEqual({
+        success: false,
+        error: "Table storage engine mismatch",
+      });
+    });
+
+    it("mysql_optimize_table should return structured error on empty tables", async () => {
+      const tool = createOptimizeTableTool(
+        mockAdapter as unknown as MySQLAdapter,
+      );
+      const result = await tool.handler({}, mockContext);
+
+      expect(result).toHaveProperty("success", false);
+      expect(result).toHaveProperty("error");
+    });
+
+    it("mysql_analyze_table should return structured error on adapter failure", async () => {
+      mockAdapter.executeQuery.mockRejectedValue(
+        new Error("Access denied for user"),
+      );
+
+      const tool = createAnalyzeTableTool(
+        mockAdapter as unknown as MySQLAdapter,
+      );
+      const result = await tool.handler({ tables: ["products"] }, mockContext);
+
+      expect(result).toEqual({
+        success: false,
+        error: "Access denied for user",
+      });
+    });
+
+    it("mysql_analyze_table should return structured error on empty tables", async () => {
+      const tool = createAnalyzeTableTool(
+        mockAdapter as unknown as MySQLAdapter,
+      );
+      const result = await tool.handler({}, mockContext);
+
+      expect(result).toHaveProperty("success", false);
+      expect(result).toHaveProperty("error");
+    });
+
+    it("mysql_check_table should return structured error on adapter failure", async () => {
+      mockAdapter.rawQuery.mockRejectedValue(
+        new Error("Lock wait timeout exceeded"),
+      );
+
+      const tool = createCheckTableTool(mockAdapter as unknown as MySQLAdapter);
+      const result = await tool.handler({ tables: ["orders"] }, mockContext);
+
+      expect(result).toEqual({
+        success: false,
+        error: "Lock wait timeout exceeded",
+      });
+    });
+
+    it("mysql_check_table should return structured error on empty tables", async () => {
+      const tool = createCheckTableTool(mockAdapter as unknown as MySQLAdapter);
+      const result = await tool.handler({}, mockContext);
+
+      expect(result).toHaveProperty("success", false);
+      expect(result).toHaveProperty("error");
+    });
+
+    it("mysql_repair_table should return structured error on adapter failure", async () => {
+      mockAdapter.executeQuery.mockRejectedValue(
+        new Error("Table is read only"),
+      );
+
+      const tool = createRepairTableTool(
+        mockAdapter as unknown as MySQLAdapter,
+      );
+      const result = await tool.handler({ tables: ["broken"] }, mockContext);
+
+      expect(result).toEqual({
+        success: false,
+        error: "Table is read only",
+      });
+    });
+
+    it("mysql_repair_table should return structured error on empty tables", async () => {
+      const tool = createRepairTableTool(
+        mockAdapter as unknown as MySQLAdapter,
+      );
+      const result = await tool.handler({}, mockContext);
+
+      expect(result).toHaveProperty("success", false);
+      expect(result).toHaveProperty("error");
+    });
+  });
+
+  describe("repair_table alias support", () => {
+    it("should accept table alias (singular string)", async () => {
+      mockAdapter.executeQuery.mockResolvedValue(createMockQueryResult([]));
+
+      const tool = createRepairTableTool(
+        mockAdapter as unknown as MySQLAdapter,
+      );
+      await tool.handler({ table: "users" }, mockContext);
+
+      expect(mockAdapter.executeQuery).toHaveBeenCalledWith(
+        "REPAIR TABLE `users`",
+      );
+    });
+
+    it("should accept tableName alias", async () => {
+      mockAdapter.executeQuery.mockResolvedValue(createMockQueryResult([]));
+
+      const tool = createRepairTableTool(
+        mockAdapter as unknown as MySQLAdapter,
+      );
+      await tool.handler({ tableName: "orders" }, mockContext);
+
+      expect(mockAdapter.executeQuery).toHaveBeenCalledWith(
+        "REPAIR TABLE `orders`",
+      );
+    });
+
+    it("should accept name alias", async () => {
+      mockAdapter.executeQuery.mockResolvedValue(createMockQueryResult([]));
+
+      const tool = createRepairTableTool(
+        mockAdapter as unknown as MySQLAdapter,
+      );
+      await tool.handler({ name: "products" }, mockContext);
+
+      expect(mockAdapter.executeQuery).toHaveBeenCalledWith(
+        "REPAIR TABLE `products`",
+      );
+    });
+
+    it("should prefer tables array over aliases", async () => {
+      mockAdapter.executeQuery.mockResolvedValue(createMockQueryResult([]));
+
+      const tool = createRepairTableTool(
+        mockAdapter as unknown as MySQLAdapter,
+      );
+      await tool.handler(
+        { tables: ["t1", "t2"], table: "ignored" },
+        mockContext,
+      );
+
+      expect(mockAdapter.executeQuery).toHaveBeenCalledWith(
+        "REPAIR TABLE `t1`, `t2`",
+      );
     });
   });
 
@@ -581,6 +752,7 @@ describe("Admin Maintenance Tools", () => {
 
       expect(result).toEqual({
         success: false,
+        error: "Tables not found: nonexistent_xyz",
         notFound: ["nonexistent_xyz"],
         flushed: ["users"],
       });
@@ -603,6 +775,7 @@ describe("Admin Maintenance Tools", () => {
 
       expect(result).toEqual({
         success: false,
+        error: "Tables not found: nonexistent_a, nonexistent_b",
         notFound: ["nonexistent_a", "nonexistent_b"],
         flushed: [],
       });
@@ -632,5 +805,68 @@ describe("Admin Maintenance Tools", () => {
         "FLUSH TABLES `users`, `orders`",
       );
     });
+
+    it("should return structured error on Zod validation failure", async () => {
+      const tool = createFlushTablesTool(
+        mockAdapter as unknown as MySQLAdapter,
+      );
+      // Pass invalid type for tables (number instead of array)
+      const result = await tool.handler(
+        { tables: 12345 as unknown },
+        mockContext,
+      );
+
+      expect(result).toHaveProperty("success", false);
+      expect(result).toHaveProperty("error");
+      // Should NOT throw — should return structured response
+      expect(typeof (result as { error: string }).error).toBe("string");
+    });
+
+    it("should return structured error on adapter failure", async () => {
+      mockAdapter.executeQuery.mockRejectedValue(
+        new Error("Access denied; you need the RELOAD privilege"),
+      );
+
+      const tool = createFlushTablesTool(
+        mockAdapter as unknown as MySQLAdapter,
+      );
+      const result = await tool.handler({}, mockContext);
+
+      expect(result).toEqual({
+        success: false,
+        error: "Access denied; you need the RELOAD privilege",
+      });
+    });
+  });
+
+  describe("kill_query Zod validation", () => {
+    it("should return structured error when processId is missing", async () => {
+      const tool = createKillQueryTool(mockAdapter as unknown as MySQLAdapter);
+      // Pass empty params — processId is required
+      const result = await tool.handler({}, mockContext);
+
+      expect(result).toHaveProperty("success", false);
+      expect(result).toHaveProperty("error");
+      expect(typeof (result as { error: string }).error).toBe("string");
+    });
+  });
+
+  describe("Zod error human-readability", () => {
+    it("should return human-readable error messages, not raw JSON arrays", async () => {
+      const tool = createOptimizeTableTool(
+        mockAdapter as unknown as MySQLAdapter,
+      );
+      // Empty params triggers Zod validation error
+      const result = (await tool.handler({}, mockContext)) as {
+        success: boolean;
+        error: string;
+      };
+
+      expect(result.success).toBe(false);
+      // The error should NOT be a raw JSON array string (starting with "[{")
+      expect(result.error).not.toMatch(/^\s*\[/);
+      // Should be a clean human-readable message
+      expect(result.error).toBeTruthy();
+    });
   });
 });