@neverinfamous/mysql-mcp 2.3.0 → 3.0.0

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

@@ -30,15 +30,16 @@ describe("Security: Validation Flow Integration", () => {
       const exportTool = tools.find((t) => t.name === "mysql_export_table")!;
 
       // Malicious input should be rejected BEFORE any database call
-      await expect(
-        exportTool.handler(
-          {
-            table: "users'; DROP TABLE users; --",
-            format: "SQL",
-          },
-          mockContext,
-        ),
-      ).rejects.toThrow();
+      const result = (await exportTool.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");
 
       // Verify NO database query was executed
       expect(mockAdapter.executeReadQuery).not.toHaveBeenCalled();
@@ -94,23 +95,19 @@ describe("Security: Validation Flow Integration", () => {
       const tools = getBackupTools(mockAdapter as unknown as MySQLAdapter);
       const exportTool = tools.find((t) => t.name === "mysql_export_table")!;
 
-      try {
-        await exportTool.handler(
-          {
-            table: "admin'; SELECT * FROM secrets; --",
-            format: "SQL",
-          },
-          mockContext,
-        );
-        expect.fail("Should have thrown");
-      } catch (error) {
-        // Error should indicate invalid input but not reveal regex pattern
-        expect(error).toBeInstanceOf(ValidationError);
-        const message = (error as Error).message;
-        expect(message).not.toContain("regex");
-        expect(message).not.toContain("/^[a-zA-Z");
-        expect(message).not.toContain("secrets"); // Shouldn't echo user input
-      }
+      const result = (await exportTool.handler(
+        {
+          table: "admin'; SELECT * FROM secrets; --",
+          format: "SQL",
+        },
+        mockContext,
+      )) as { success: boolean; error: string };
+
+      expect(result.success).toBe(false);
+      // Error should indicate invalid input but not reveal regex pattern
+      expect(result.error).not.toContain("regex");
+      expect(result.error).not.toContain("/^[a-zA-Z");
+      expect(result.error).not.toContain("secrets"); // Shouldn't echo user input
     });
 
     it("should not expose database schema information in errors", async () => {
@@ -141,21 +138,18 @@ describe("Security: Validation Flow Integration", () => {
       const tools = getBackupTools(mockAdapter as unknown as MySQLAdapter);
       const exportTool = tools.find((t) => t.name === "mysql_export_table")!;
 
-      try {
-        await exportTool.handler(
-          {
-            table: "123invalid",
-            format: "SQL",
-          },
-          mockContext,
-        );
-        expect.fail("Should have thrown");
-      } catch (error) {
-        const message = (error as Error).message;
-        // Error should be helpful but not technical
-        expect(message).toContain("table");
-        expect(message).not.toContain("IDENTIFIER_PATTERN");
-      }
+      const result = (await exportTool.handler(
+        {
+          table: "123invalid",
+          format: "SQL",
+        },
+        mockContext,
+      )) as { success: boolean; error: string };
+
+      expect(result.success).toBe(false);
+      // Error should be helpful but not technical
+      expect(result.error).toContain("table");
+      expect(result.error).not.toContain("IDENTIFIER_PATTERN");
     });
   });
 
@@ -174,16 +168,19 @@ describe("Security: Validation Flow Integration", () => {
       )!;
       const jsonTool = jsonTools.find((t) => t.name === "mysql_json_extract")!;
 
-      await expect(
-        exportTool.handler(
-          {
-            table: maliciousTable,
-            format: "SQL",
-          },
-          mockContext,
-        ),
-      ).rejects.toThrow("Invalid table name");
+      // Backup tools return structured errors (caught by try/catch)
+      const exportResult = (await exportTool.handler(
+        {
+          table: maliciousTable,
+          format: "SQL",
+        },
+        mockContext,
+      )) as { success: boolean; error: string };
+
+      expect(exportResult.success).toBe(false);
+      expect(exportResult.error).toContain("Invalid table name");
 
+      // JSON tools still throw (different error handling pattern)
       await expect(
         jsonTool.handler(
           {

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

@@ -140,7 +140,7 @@ describe("Handler Execution", () => {
     });
 
     it("should return structured error for nullable columns", async () => {
-      // Column is nullable - should return { success: false, reason }
+      // Column is nullable - should return { success: false, error }
       mockAdapter.executeQuery.mockResolvedValueOnce(
         createMockQueryResult([{ IS_NULLABLE: "YES", DATA_TYPE: "point" }]),
       );
@@ -157,13 +157,13 @@ describe("Handler Execution", () => {
 
       expect(result).toEqual({
         success: false,
-        reason: expect.stringContaining(
+        error: expect.stringContaining(
           "Cannot create SPATIAL index on nullable column",
         ),
       });
     });
 
-    it("should return structured reason for duplicate index", async () => {
+    it("should return structured error for duplicate index", async () => {
       // First call: column info, second: no existing index, third: fails with duplicate key
       mockAdapter.executeQuery
         .mockResolvedValueOnce(
@@ -188,8 +188,7 @@ describe("Handler Execution", () => {
 
       expect(result).toEqual({
         success: false,
-        reason:
-          "Index 'idx_locations_geom' already exists on table 'locations'",
+        error: "Index 'idx_locations_geom' already exists on table 'locations'",
       });
     });
 
@@ -468,11 +467,13 @@ describe("Handler Execution", () => {
 
     it("should handle logic fallback (coverage)", async () => {
       const tool = tools.find((t) => t.name === "mysql_spatial_geojson")!;
-      try {
-        await tool.handler({ geometry: "" }, mockContext);
-      } catch (error) {
-        expect(error).toBeDefined();
-      }
+      // geometry: "" passes Zod refine (string is defined) but is falsy,
+      // so handler falls through to the structured error return
+      const result = await tool.handler({ geometry: "" }, mockContext);
+      expect(result).toEqual({
+        success: false,
+        error: "Either geometry or geoJson must be provided",
+      });
     });
   });
 });

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

@@ -22,28 +22,38 @@ describe("Spatial Tools Handlers", () => {
   const findTool = (name: string) => tools.find((t) => t.name === name);
 
   describe("mysql_spatial_create_column", () => {
-    it("should validate table and column names", async () => {
+    it("should return structured error for invalid table name", async () => {
       const tool = findTool("mysql_spatial_create_column")!;
 
-      await expect(
-        tool.handler(
-          {
-            table: "invalid table",
-            column: "geom",
-          },
-          mockContext,
-        ),
-      ).rejects.toThrow("Invalid table name");
+      const result = await tool.handler(
+        {
+          table: "invalid table",
+          column: "geom",
+        },
+        mockContext,
+      );
 
-      await expect(
-        tool.handler(
-          {
-            table: "users",
-            column: "invalid-column",
-          },
-          mockContext,
-        ),
-      ).rejects.toThrow("Invalid column name");
+      expect(result).toEqual({
+        success: false,
+        error: expect.stringContaining("Invalid table name"),
+      });
+    });
+
+    it("should return structured error for invalid column name", async () => {
+      const tool = findTool("mysql_spatial_create_column")!;
+
+      const result = await tool.handler(
+        {
+          table: "users",
+          column: "invalid-column",
+        },
+        mockContext,
+      );
+
+      expect(result).toEqual({
+        success: false,
+        error: "Invalid column name",
+      });
     });
 
     it("should execute ALTER TABLE with correct types", async () => {
@@ -70,19 +80,22 @@ describe("Spatial Tools Handlers", () => {
   });
 
   describe("mysql_spatial_create_index", () => {
-    it("should validate identifiers", async () => {
+    it("should return structured error for invalid identifiers", async () => {
       const tool = findTool("mysql_spatial_create_index")!;
 
-      await expect(
-        tool.handler(
-          {
-            table: "users",
-            column: "location",
-            indexName: "bad-index",
-          },
-          mockContext,
-        ),
-      ).rejects.toThrow("Invalid index name");
+      const result = await tool.handler(
+        {
+          table: "users",
+          column: "location",
+          indexName: "bad-index",
+        },
+        mockContext,
+      );
+
+      expect(result).toEqual({
+        success: false,
+        error: "Invalid index name",
+      });
     });
 
     it("should generate default index name if not provided", async () => {
@@ -135,7 +148,7 @@ describe("Spatial Tools Handlers", () => {
 
       expect(result).toEqual({
         success: false,
-        reason:
+        error:
           "Spatial index 'idx_existing_geom' already exists on column 'geom' of table 'locations'",
       });
       // Should have called: 1) column check, 2) existing index check — NOT the CREATE
@@ -224,12 +237,15 @@ describe("Spatial Tools Handlers", () => {
       expect((result as any).wkt).toBe("POINT(1 1)");
     });
 
-    it("should throw if both inputs are missing (zod refinement)", async () => {
+    it("should return structured error if both inputs are missing (zod refinement)", async () => {
       const tool = findTool("mysql_spatial_geojson")!;
-      // Note: Zod error comes from parse, which happens inside handler but Zod throws it.
-      // We can check if it throws "Either geometry or geoJson must be provided"
-      // Actually Zod throws ZodError, but our tool catches? No handler doesn't catch.
-      await expect(tool.handler({}, mockContext)).rejects.toThrow();
+      const result = await tool.handler({}, mockContext);
+      expect(result).toEqual({
+        success: false,
+        error: expect.stringContaining(
+          "Either geometry or geoJson must be provided",
+        ),
+      });
     });
   });
 
@@ -461,7 +477,7 @@ describe("Spatial Tools Handlers", () => {
       });
     });
 
-    it("should return { success: false, reason } for duplicate column (create_column)", async () => {
+    it("should return { success: false, error } for duplicate column (create_column)", async () => {
       const tool = findTool("mysql_spatial_create_column")!;
       mockAdapter.executeQuery.mockRejectedValueOnce(
         new Error("Duplicate column name 'location'"),
@@ -477,7 +493,7 @@ describe("Spatial Tools Handlers", () => {
 
       expect(result).toEqual({
         success: false,
-        reason: "Column 'location' already exists on table 'users'",
+        error: "Column 'location' already exists on table 'users'",
       });
     });