@neverinfamous/mysql-mcp 2.3.0 → 3.0.0

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

@@ -380,6 +380,29 @@ describe("Handler Execution", () => {
       expect(calls.some((c) => c.includes("ANALYZE TABLE"))).toBe(true);
     });
 
+    it("should include warning when buckets exceed 1024", async () => {
+      mockAdapter.executeQuery.mockResolvedValue(
+        createMockQueryResult([{ TABLE_NAME: "orders" }]),
+      );
+
+      const tool = tools.find((t) => t.name === "mysql_stats_histogram")!;
+      const result = (await tool.handler(
+        { table: "orders", column: "total", update: true, buckets: 2000 },
+        mockContext,
+      )) as { warning?: string };
+
+      // Verify ANALYZE TABLE used clamped value
+      const calls = mockAdapter.executeQuery.mock.calls.map(
+        (c) => c[0] as string,
+      );
+      const analyzeCall = calls.find((c) => c.includes("ANALYZE TABLE"));
+      expect(analyzeCall).toContain("1024 BUCKETS");
+
+      expect(result.warning).toBe(
+        "Requested 2000 buckets; clamped to max 1024",
+      );
+    });
+
     it("should return histogram metadata when exists", async () => {
       mockAdapter.executeQuery.mockResolvedValue(
         createMockQueryResult([
@@ -421,56 +444,60 @@ describe("Stats Validation Errors", () => {
   describe("mysql_stats_descriptive", () => {
     it("should reject invalid table name", async () => {
       const tool = tools.find((t) => t.name === "mysql_stats_descriptive")!;
-      await expect(
-        tool.handler(
-          {
-            table: "123-invalid",
-            column: "total",
-          },
-          mockContext,
-        ),
-      ).rejects.toThrow("Invalid table name");
+      const result = (await tool.handler(
+        {
+          table: "123-invalid",
+          column: "total",
+        },
+        mockContext,
+      )) as { success: boolean; error: string };
+
+      expect(result.success).toBe(false);
+      expect(result.error).toContain("Invalid table name");
     });
 
     it("should reject invalid column name", async () => {
       const tool = tools.find((t) => t.name === "mysql_stats_descriptive")!;
-      await expect(
-        tool.handler(
-          {
-            table: "orders",
-            column: "123-bad",
-          },
-          mockContext,
-        ),
-      ).rejects.toThrow("Invalid column name");
+      const result = (await tool.handler(
+        {
+          table: "orders",
+          column: "123-bad",
+        },
+        mockContext,
+      )) as { success: boolean; error: string };
+
+      expect(result.success).toBe(false);
+      expect(result.error).toContain("Invalid column name");
     });
   });
 
   describe("mysql_stats_percentiles", () => {
     it("should reject invalid table name", async () => {
       const tool = tools.find((t) => t.name === "mysql_stats_percentiles")!;
-      await expect(
-        tool.handler(
-          {
-            table: "123-invalid",
-            column: "amount",
-          },
-          mockContext,
-        ),
-      ).rejects.toThrow("Invalid table name");
+      const result = (await tool.handler(
+        {
+          table: "123-invalid",
+          column: "amount",
+        },
+        mockContext,
+      )) as { success: boolean; error: string };
+
+      expect(result.success).toBe(false);
+      expect(result.error).toContain("Invalid table name");
     });
 
     it("should reject invalid column name", async () => {
       const tool = tools.find((t) => t.name === "mysql_stats_percentiles")!;
-      await expect(
-        tool.handler(
-          {
-            table: "orders",
-            column: "bad-col",
-          },
-          mockContext,
-        ),
-      ).rejects.toThrow("Invalid column name");
+      const result = (await tool.handler(
+        {
+          table: "orders",
+          column: "bad-col",
+        },
+        mockContext,
+      )) as { success: boolean; error: string };
+
+      expect(result.success).toBe(false);
+      expect(result.error).toContain("Invalid column name");
     });
 
     it("should return empty percentiles when table is empty", async () => {
@@ -494,58 +521,62 @@ describe("Stats Validation Errors", () => {
   describe("mysql_stats_correlation", () => {
     it("should reject invalid table name", async () => {
       const tool = tools.find((t) => t.name === "mysql_stats_correlation")!;
-      await expect(
-        tool.handler(
-          {
-            table: "123-bad",
-            column1: "x",
-            column2: "y",
-          },
-          mockContext,
-        ),
-      ).rejects.toThrow("Invalid table name");
+      const result = (await tool.handler(
+        {
+          table: "123-bad",
+          column1: "x",
+          column2: "y",
+        },
+        mockContext,
+      )) as { success: boolean; error: string };
+
+      expect(result.success).toBe(false);
+      expect(result.error).toContain("Invalid table name");
     });
 
     it("should reject invalid column names", async () => {
       const tool = tools.find((t) => t.name === "mysql_stats_correlation")!;
-      await expect(
-        tool.handler(
-          {
-            table: "data",
-            column1: "bad-col",
-            column2: "y",
-          },
-          mockContext,
-        ),
-      ).rejects.toThrow("Invalid column name");
+      const result = (await tool.handler(
+        {
+          table: "data",
+          column1: "bad-col",
+          column2: "y",
+        },
+        mockContext,
+      )) as { success: boolean; error: string };
+
+      expect(result.success).toBe(false);
+      expect(result.error).toContain("Invalid column name");
     });
   });
 
   describe("mysql_stats_distribution", () => {
     it("should reject invalid table name", async () => {
       const tool = tools.find((t) => t.name === "mysql_stats_distribution")!;
-      await expect(
-        tool.handler(
-          {
-            table: "123-bad",
-            column: "amount",
-          },
-          mockContext,
-        ),
-      ).rejects.toThrow("Invalid table name");
+      const result = (await tool.handler(
+        {
+          table: "123-bad",
+          column: "amount",
+        },
+        mockContext,
+      )) as { success: boolean; error: string };
+
+      expect(result.success).toBe(false);
+      expect(result.error).toContain("Invalid table name");
     });
 
     it("should reject invalid column name", async () => {
       const tool = tools.find((t) => t.name === "mysql_stats_distribution")!;
-      await expect(
-        tool.handler(
-          {
-            table: "orders",
-            column: "bad-col",
-          },
-          mockContext,
-        ),
-      ).rejects.toThrow("Invalid column name");
+      const result = (await tool.handler(
+        {
+          table: "orders",
+          column: "bad-col",
+        },
+        mockContext,
+      )) as { success: boolean; error: string };
+
+      expect(result.success).toBe(false);
+      expect(result.error).toContain("Invalid column name");
     });
 
     it("should handle same min/max values", async () => {
@@ -569,30 +600,32 @@ describe("Stats Validation Errors", () => {
   describe("mysql_stats_time_series", () => {
     it("should reject invalid table name", async () => {
       const tool = tools.find((t) => t.name === "mysql_stats_time_series")!;
-      await expect(
-        tool.handler(
-          {
-            table: "123-bad",
-            valueColumn: "amount",
-            timeColumn: "created_at",
-          },
-          mockContext,
-        ),
-      ).rejects.toThrow("Invalid table name");
+      const result = (await tool.handler(
+        {
+          table: "123-bad",
+          valueColumn: "amount",
+          timeColumn: "created_at",
+        },
+        mockContext,
+      )) as { success: boolean; error: string };
+
+      expect(result.success).toBe(false);
+      expect(result.error).toContain("Invalid table name");
     });
 
     it("should reject invalid column names", async () => {
       const tool = tools.find((t) => t.name === "mysql_stats_time_series")!;
-      await expect(
-        tool.handler(
-          {
-            table: "sales",
-            valueColumn: "bad-col",
-            timeColumn: "created_at",
-          },
-          mockContext,
-        ),
-      ).rejects.toThrow("Invalid column name");
+      const result = (await tool.handler(
+        {
+          table: "sales",
+          valueColumn: "bad-col",
+          timeColumn: "created_at",
+        },
+        mockContext,
+      )) as { success: boolean; error: string };
+
+      expect(result.success).toBe(false);
+      expect(result.error).toContain("Invalid column name");
     });
 
     it("should use different interval formats", async () => {
@@ -618,30 +651,32 @@ describe("Stats Validation Errors", () => {
   describe("mysql_stats_regression", () => {
     it("should reject invalid table name", async () => {
       const tool = tools.find((t) => t.name === "mysql_stats_regression")!;
-      await expect(
-        tool.handler(
-          {
-            table: "123-bad",
-            xColumn: "x",
-            yColumn: "y",
-          },
-          mockContext,
-        ),
-      ).rejects.toThrow("Invalid table name");
+      const result = (await tool.handler(
+        {
+          table: "123-bad",
+          xColumn: "x",
+          yColumn: "y",
+        },
+        mockContext,
+      )) as { success: boolean; error: string };
+
+      expect(result.success).toBe(false);
+      expect(result.error).toContain("Invalid table name");
     });
 
     it("should reject invalid column names", async () => {
       const tool = tools.find((t) => t.name === "mysql_stats_regression")!;
-      await expect(
-        tool.handler(
-          {
-            table: "data",
-            xColumn: "bad-x",
-            yColumn: "y",
-          },
-          mockContext,
-        ),
-      ).rejects.toThrow("Invalid column name");
+      const result = (await tool.handler(
+        {
+          table: "data",
+          xColumn: "bad-x",
+          yColumn: "y",
+        },
+        mockContext,
+      )) as { success: boolean; error: string };
+
+      expect(result.success).toBe(false);
+      expect(result.error).toContain("Invalid column name");
     });
 
     it("should return error for insufficient data points", async () => {
@@ -663,8 +698,9 @@ describe("Stats Validation Errors", () => {
           yColumn: "y",
         },
         mockContext,
-      )) as { error: string };
+      )) as { success: boolean; error: string };
 
+      expect(result.success).toBe(false);
       expect(result.error).toContain("Insufficient");
     });
   });
@@ -672,29 +708,31 @@ describe("Stats Validation Errors", () => {
   describe("mysql_stats_sampling", () => {
     it("should reject invalid table name", async () => {
       const tool = tools.find((t) => t.name === "mysql_stats_sampling")!;
-      await expect(
-        tool.handler(
-          {
-            table: "123-bad",
-            sampleSize: 10,
-          },
-          mockContext,
-        ),
-      ).rejects.toThrow("Invalid table name");
+      const result = (await tool.handler(
+        {
+          table: "123-bad",
+          sampleSize: 10,
+        },
+        mockContext,
+      )) as { success: boolean; error: string };
+
+      expect(result.success).toBe(false);
+      expect(result.error).toContain("Invalid table name");
     });
 
     it("should reject invalid column names", async () => {
       const tool = tools.find((t) => t.name === "mysql_stats_sampling")!;
-      await expect(
-        tool.handler(
-          {
-            table: "users",
-            sampleSize: 10,
-            columns: ["valid", "bad-column"],
-          },
-          mockContext,
-        ),
-      ).rejects.toThrow("Invalid column name");
+      const result = (await tool.handler(
+        {
+          table: "users",
+          sampleSize: 10,
+          columns: ["valid", "bad-column"],
+        },
+        mockContext,
+      )) as { success: boolean; error: string };
+
+      expect(result.success).toBe(false);
+      expect(result.error).toContain("Invalid column name");
     });
 
     it("should use seed for reproducibility", async () => {
@@ -718,28 +756,30 @@ describe("Stats Validation Errors", () => {
   describe("mysql_stats_histogram", () => {
     it("should reject invalid table name", async () => {
       const tool = tools.find((t) => t.name === "mysql_stats_histogram")!;
-      await expect(
-        tool.handler(
-          {
-            table: "123-bad",
-            column: "amount",
-          },
-          mockContext,
-        ),
-      ).rejects.toThrow("Invalid table name");
+      const result = (await tool.handler(
+        {
+          table: "123-bad",
+          column: "amount",
+        },
+        mockContext,
+      )) as { success: boolean; error: string };
+
+      expect(result.success).toBe(false);
+      expect(result.error).toContain("Invalid table name");
     });
 
     it("should reject invalid column name", async () => {
       const tool = tools.find((t) => t.name === "mysql_stats_histogram")!;
-      await expect(
-        tool.handler(
-          {
-            table: "orders",
-            column: "bad-col",
-          },
-          mockContext,
-        ),
-      ).rejects.toThrow("Invalid column name");
+      const result = (await tool.handler(
+        {
+          table: "orders",
+          column: "bad-col",
+        },
+        mockContext,
+      )) as { success: boolean; error: string };
+
+      expect(result.success).toBe(false);
+      expect(result.error).toContain("Invalid column name");
     });
   });
 });
@@ -883,3 +923,96 @@ describe("Stats Nonexistent Table Handling", () => {
     expect(result.error).toContain("Unknown column");
   });
 });
+
+describe("Stats Zod Validation Guards", () => {
+  let tools: ReturnType<typeof getStatsTools>;
+  let mockContext: ReturnType<typeof createMockRequestContext>;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    const mockAdapter = createMockMySQLAdapter();
+    tools = getStatsTools(mockAdapter as unknown as MySQLAdapter);
+    mockContext = createMockRequestContext();
+  });
+
+  it("mysql_stats_time_series returns structured error for invalid interval", async () => {
+    const tool = tools.find((t) => t.name === "mysql_stats_time_series")!;
+    const result = (await tool.handler(
+      {
+        table: "sales",
+        valueColumn: "amount",
+        timeColumn: "created_at",
+        interval: "invalid_interval",
+      },
+      mockContext,
+    )) as { success: boolean; error: string };
+
+    expect(result.success).toBe(false);
+    expect(result.error).toContain("Invalid interval");
+    expect(result.error).toContain("invalid_interval");
+  });
+
+  it("mysql_stats_time_series returns structured error for invalid aggregation", async () => {
+    const tool = tools.find((t) => t.name === "mysql_stats_time_series")!;
+    const result = (await tool.handler(
+      {
+        table: "sales",
+        valueColumn: "amount",
+        timeColumn: "created_at",
+        aggregation: "invalid_agg",
+      },
+      mockContext,
+    )) as { success: boolean; error: string };
+
+    expect(result.success).toBe(false);
+    expect(result.error).toContain("Invalid aggregation");
+    expect(result.error).toContain("invalid_agg");
+  });
+
+  it("mysql_stats_sampling returns structured error for negative sampleSize", async () => {
+    const tool = tools.find((t) => t.name === "mysql_stats_sampling")!;
+    const result = (await tool.handler(
+      {
+        table: "users",
+        sampleSize: -1,
+      },
+      mockContext,
+    )) as { success: boolean; error: string };
+
+    expect(result.success).toBe(false);
+    expect(result.error).toContain("sampleSize");
+  });
+
+  it("mysql_stats_correlation returns structured error for missing required fields", async () => {
+    const tool = tools.find((t) => t.name === "mysql_stats_correlation")!;
+    const result = (await tool.handler({}, mockContext)) as {
+      success: boolean;
+      error: string;
+    };
+
+    expect(result.success).toBe(false);
+    expect(result.error).toBeDefined();
+  });
+
+  it("mysql_stats_regression returns structured error for missing required fields", async () => {
+    const tool = tools.find((t) => t.name === "mysql_stats_regression")!;
+    const result = (await tool.handler({}, mockContext)) as {
+      success: boolean;
+      error: string;
+    };
+
+    expect(result.success).toBe(false);
+    expect(result.error).toBeDefined();
+  });
+
+  it("mysql_stats_histogram returns structured error for missing required fields", async () => {
+    const tool = tools.find((t) => t.name === "mysql_stats_histogram")!;
+    const result = (await tool.handler({}, mockContext)) as {
+      success: boolean;
+      error: string;
+    };
+
+    expect(result.success).toBe(false);
+    expect(result.error).toBeDefined();
+  });
+});

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

@@ -168,8 +168,8 @@ describe("Handler Execution", () => {
       const result = await tool.handler({ transactionId: "gone" }, mockContext);
 
       expect(result).toHaveProperty("success", false);
-      expect(result).toHaveProperty("reason");
-      expect((result as { reason: string }).reason).toContain(
+      expect(result).toHaveProperty("error");
+      expect((result as { error: string }).error).toContain(
         "Transaction not found",
       );
     });
@@ -197,8 +197,8 @@ describe("Handler Execution", () => {
       const result = await tool.handler({ transactionId: "gone" }, mockContext);
 
       expect(result).toHaveProperty("success", false);
-      expect(result).toHaveProperty("reason");
-      expect((result as { reason: string }).reason).toContain(
+      expect(result).toHaveProperty("error");
+      expect((result as { error: string }).error).toContain(
         "Transaction not found",
       );
     });
@@ -237,7 +237,7 @@ describe("Handler Execution", () => {
       );
 
       expect(result).toHaveProperty("success", false);
-      expect(result).toHaveProperty("reason", "Invalid savepoint name");
+      expect(result).toHaveProperty("error", "Invalid savepoint name");
     });
 
     it("should return structured error for non-existent transaction", async () => {
@@ -256,7 +256,7 @@ describe("Handler Execution", () => {
       );
 
       expect(result).toHaveProperty("success", false);
-      expect((result as { reason: string }).reason).toContain(
+      expect((result as { error: string }).error).toContain(
         "Transaction not found",
       );
     });
@@ -292,7 +292,7 @@ describe("Handler Execution", () => {
       );
 
       expect(result).toHaveProperty("success", false);
-      expect(result).toHaveProperty("reason", "Invalid savepoint name");
+      expect(result).toHaveProperty("error", "Invalid savepoint name");
     });
 
     it("should return structured error for non-existent transaction", async () => {
@@ -311,7 +311,7 @@ describe("Handler Execution", () => {
       );
 
       expect(result).toHaveProperty("success", false);
-      expect((result as { reason: string }).reason).toContain(
+      expect((result as { error: string }).error).toContain(
         "Transaction not found",
       );
     });
@@ -351,7 +351,7 @@ describe("Handler Execution", () => {
       );
 
       expect(result).toHaveProperty("success", false);
-      expect(result).toHaveProperty("reason", "Invalid savepoint name");
+      expect(result).toHaveProperty("error", "Invalid savepoint name");
     });
 
     it("should return structured error for non-existent transaction", async () => {
@@ -372,7 +372,7 @@ describe("Handler Execution", () => {
       );
 
       expect(result).toHaveProperty("success", false);
-      expect((result as { reason: string }).reason).toContain(
+      expect((result as { error: string }).error).toContain(
         "Transaction not found",
       );
     });
@@ -383,8 +383,8 @@ describe("Handler Execution", () => {
       const tool = tools.find((t) => t.name === "mysql_transaction_execute")!;
       const result = await tool.handler({ statements: [] }, mockContext);
       expect(result).toHaveProperty("success", false);
-      expect(result).toHaveProperty("reason");
-      expect((result as { reason: string }).reason).toContain("No statements");
+      expect(result).toHaveProperty("error");
+      expect((result as { error: string }).error).toContain("No statements");
       expect(mockAdapter.beginTransaction).not.toHaveBeenCalled();
     });
 
@@ -473,7 +473,7 @@ describe("Handler Execution", () => {
       expect(mockAdapter.rollbackTransaction).toHaveBeenCalled();
       expect(result).toHaveProperty("success", false);
       expect(result).toHaveProperty("rolledBack", true);
-      expect((result as { reason: string }).reason).toContain(
+      expect((result as { error: string }).error).toContain(
         "Transaction failed and was rolled back",
       );
     });