@neverinfamous/mysql-mcp 2.1.0 → 2.3.0

package/src/adapters/mysql/tools/json/__tests__/helpers.test.ts

@@ -1,94 +1,215 @@
 /**
  * mysql-mcp - JSON Helper Tools Unit Tests
- * 
+ *
  * Comprehensive tests for helpers.ts module functions.
  */
 
-import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { describe, it, expect, vi, beforeEach } from "vitest";
 import {
-    createJsonGetTool,
-    createJsonUpdateTool,
-    createJsonSearchTool,
-    createJsonValidateTool
-} from '../helpers.js';
-import type { MySQLAdapter } from '../../MySQLAdapter.js';
-import { createMockMySQLAdapter, createMockRequestContext, createMockQueryResult } from '../../../../../__tests__/mocks/index.js';
-
-describe('JSON Helper Tools', () => {
-    let mockAdapter: ReturnType<typeof createMockMySQLAdapter>;
-    let mockContext: ReturnType<typeof createMockRequestContext>;
-
-    beforeEach(() => {
-        vi.clearAllMocks();
-        mockAdapter = createMockMySQLAdapter();
-        mockContext = createMockRequestContext();
+  createJsonGetTool,
+  createJsonUpdateTool,
+  createJsonSearchTool,
+  createJsonValidateTool,
+} from "../helpers.js";
+import type { MySQLAdapter } from "../../../MySQLAdapter.js";
+import {
+  createMockMySQLAdapter,
+  createMockRequestContext,
+  createMockQueryResult,
+} from "../../../../../__tests__/mocks/index.js";
+
+describe("JSON Helper Tools", () => {
+  let mockAdapter: ReturnType<typeof createMockMySQLAdapter>;
+  let mockContext: ReturnType<typeof createMockRequestContext>;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mockAdapter = createMockMySQLAdapter();
+    mockContext = createMockRequestContext();
+  });
+
+  describe("createJsonGetTool", () => {
+    it("should get JSON value by ID", async () => {
+      mockAdapter.executeReadQuery.mockResolvedValue(
+        createMockQueryResult([{ value: '{"a":1}' }]),
+      );
+
+      const tool = createJsonGetTool(mockAdapter as unknown as MySQLAdapter);
+      const result = (await tool.handler(
+        {
+          table: "data",
+          column: "json_col",
+          path: "$.a",
+          id: 1,
+        },
+        mockContext,
+      )) as { value: any };
+
+      expect(mockAdapter.executeReadQuery).toHaveBeenCalled();
+      const call = mockAdapter.executeReadQuery.mock.calls[0][0] as string;
+      expect(call).toContain("JSON_EXTRACT");
+      expect(call).toContain("WHERE `id` = ?");
+      // Value is parsed from JSON string
+      expect(result.value).toEqual({ a: 1 });
     });
+  });
 
-    describe('createJsonGetTool', () => {
-        it('should get JSON value by ID', async () => {
-            mockAdapter.executeReadQuery.mockResolvedValue(createMockQueryResult([{ value: '{"a":1}' }]));
-
-            const tool = createJsonGetTool(mockAdapter as unknown as MySQLAdapter);
-            const result = await tool.handler({
-                table: 'data',
-                column: 'json_col',
-                path: '$.a',
-                id: 1
-            }, mockContext) as { value: any };
-
-            expect(mockAdapter.executeReadQuery).toHaveBeenCalled();
-            const call = mockAdapter.executeReadQuery.mock.calls[0][0] as string;
-            expect(call).toContain('JSON_EXTRACT');
-            expect(call).toContain('WHERE `id` = ?');
-            expect(result.value).toBe('{"a":1}');
-        });
+  describe("createJsonSearchTool", () => {
+    it("should search JSON by value", async () => {
+      mockAdapter.executeReadQuery.mockResolvedValue(
+        createMockQueryResult([{ id: 1, match_path: "$[0]" }]),
+      );
+
+      const tool = createJsonSearchTool(mockAdapter as unknown as MySQLAdapter);
+      await tool.handler(
+        {
+          table: "data",
+          column: "json_col",
+          searchValue: "test",
+        },
+        mockContext,
+      );
+
+      const call = mockAdapter.executeReadQuery.mock.calls[0][0] as string;
+      expect(call).toContain("JSON_SEARCH");
+      expect(call).toContain("SELECT id, `json_col`");
+      expect(call).not.toContain("SELECT *");
     });
+  });
+
+  describe("createJsonUpdateTool", () => {
+    it("should update JSON value by ID", async () => {
+      mockAdapter.executeWriteQuery.mockResolvedValue({
+        rowsAffected: 1,
+        insertId: 0,
+      });
 
-    describe('createJsonUpdateTool', () => {
-        it('should update JSON value by ID', async () => {
-            mockAdapter.executeWriteQuery.mockResolvedValue({ rowsAffected: 1, insertId: 0 });
-
-            const tool = createJsonUpdateTool(mockAdapter as unknown as MySQLAdapter);
-            const result = await tool.handler({
-                table: 'data',
-                column: 'json_col',
-                path: '$.a',
-                value: 2,
-                id: 1
-            }, mockContext) as { success: boolean };
-
-            expect(mockAdapter.executeWriteQuery).toHaveBeenCalled();
-            expect(result.success).toBe(true);
-        });
+      const tool = createJsonUpdateTool(mockAdapter as unknown as MySQLAdapter);
+      const result = (await tool.handler(
+        {
+          table: "data",
+          column: "json_col",
+          path: "$.a",
+          value: 2,
+          id: 1,
+        },
+        mockContext,
+      )) as { success: boolean };
+
+      expect(mockAdapter.executeWriteQuery).toHaveBeenCalled();
+      expect(result.success).toBe(true);
     });
 
-    describe('createJsonSearchTool', () => {
-        it('should search JSON by value', async () => {
-            mockAdapter.executeReadQuery.mockResolvedValue(createMockQueryResult([{ id: 1, match_path: '$[0]' }]));
+    it("should return reason when no row matches the ID", async () => {
+      mockAdapter.executeWriteQuery.mockResolvedValue({
+        rowsAffected: 0,
+        insertId: 0,
+      });
 
-            const tool = createJsonSearchTool(mockAdapter as unknown as MySQLAdapter);
-            await tool.handler({
-                table: 'data',
-                column: 'json_col',
-                searchValue: 'test'
-            }, mockContext);
+      const tool = createJsonUpdateTool(mockAdapter as unknown as MySQLAdapter);
+      const result = (await tool.handler(
+        {
+          table: "data",
+          column: "json_col",
+          path: "$.a",
+          value: 2,
+          id: 999,
+        },
+        mockContext,
+      )) as { success: boolean; reason: string };
 
-            const call = mockAdapter.executeReadQuery.mock.calls[0][0] as string;
-            expect(call).toContain('JSON_SEARCH');
-        });
+      expect(result.success).toBe(false);
+      expect(result.reason).toContain("999");
     });
+  });
+
+  describe("createJsonValidateTool", () => {
+    it("should validate JSON string", async () => {
+      mockAdapter.executeReadQuery.mockResolvedValue(
+        createMockQueryResult([{ is_valid: 1 }]),
+      );
 
-    describe('createJsonValidateTool', () => {
-        it('should validate JSON string', async () => {
-            mockAdapter.executeReadQuery.mockResolvedValue(createMockQueryResult([{ is_valid: 1 }]));
+      const tool = createJsonValidateTool(
+        mockAdapter as unknown as MySQLAdapter,
+      );
+      const result = (await tool.handler(
+        {
+          value: '{"a":1}',
+        },
+        mockContext,
+      )) as { valid: boolean };
 
-            const tool = createJsonValidateTool(mockAdapter as unknown as MySQLAdapter);
-            const result = await tool.handler({
-                value: '{"a":1}'
-            }, mockContext) as { valid: boolean };
+      expect(mockAdapter.executeReadQuery).toHaveBeenCalled();
+      expect(result.valid).toBe(true);
+    });
+
+    it("should pass bare strings directly without auto-conversion", async () => {
+      mockAdapter.executeReadQuery.mockResolvedValue(
+        createMockQueryResult([{ is_valid: 0 }]),
+      );
+
+      const tool = createJsonValidateTool(
+        mockAdapter as unknown as MySQLAdapter,
+      );
+      const result = (await tool.handler(
+        {
+          value: "hello",
+        },
+        mockContext,
+      )) as { valid: boolean };
+
+      expect(mockAdapter.executeReadQuery).toHaveBeenCalled();
+      // The bare string "hello" should be passed directly, not wrapped
+      const sqlParam = mockAdapter.executeReadQuery.mock
+        .calls[0][1] as string[];
+      expect(sqlParam[0]).toBe("hello");
+      expect(result.valid).toBe(false);
+    });
+  });
+
+  describe("P154 Graceful Error Handling", () => {
+    const tableError = new Error("Table 'testdb.nonexistent' doesn't exist");
+
+    it("json_get should return exists: false for nonexistent table", async () => {
+      mockAdapter.executeReadQuery.mockRejectedValue(tableError);
+      const tool = createJsonGetTool(mockAdapter as unknown as MySQLAdapter);
+      const result = await tool.handler(
+        { table: "nonexistent", column: "doc", path: "$.x", id: 1 },
+        mockContext,
+      );
+      expect(result).toEqual({ exists: false, table: "nonexistent" });
+    });
+
+    it("json_update should return exists: false for nonexistent table", async () => {
+      mockAdapter.executeWriteQuery.mockRejectedValue(tableError);
+      const tool = createJsonUpdateTool(mockAdapter as unknown as MySQLAdapter);
+      const result = await tool.handler(
+        { table: "nonexistent", column: "doc", path: "$.x", value: 1, id: 1 },
+        mockContext,
+      );
+      expect(result).toEqual({ exists: false, table: "nonexistent" });
+    });
+
+    it("json_search should return exists: false for nonexistent table", async () => {
+      mockAdapter.executeReadQuery.mockRejectedValue(tableError);
+      const tool = createJsonSearchTool(mockAdapter as unknown as MySQLAdapter);
+      const result = await tool.handler(
+        { table: "nonexistent", column: "doc", searchValue: "test" },
+        mockContext,
+      );
+      expect(result).toEqual({ exists: false, table: "nonexistent" });
+    });
 
-            expect(mockAdapter.executeReadQuery).toHaveBeenCalled();
-            expect(result.valid).toBe(true);
-        });
+    it("should return success: false for generic errors", async () => {
+      mockAdapter.executeReadQuery.mockRejectedValue(
+        new Error("Connection lost"),
+      );
+      const tool = createJsonGetTool(mockAdapter as unknown as MySQLAdapter);
+      const result = await tool.handler(
+        { table: "data", column: "doc", path: "$.x", id: 1 },
+        mockContext,
+      );
+      expect(result).toEqual({ success: false, error: "Connection lost" });
     });
+  });
 });

package/src/adapters/mysql/tools/json/__tests__/validation.test.ts

@@ -1,83 +1,117 @@
-
-import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import {
+  createJsonSetTool,
+  createJsonInsertTool,
+  createJsonReplaceTool,
+  createJsonArrayAppendTool,
+} from "../core.js";
+import type { MySQLAdapter } from "../../../MySQLAdapter.js";
 import {
-    createJsonSetTool,
-    createJsonInsertTool,
-    createJsonReplaceTool,
-    createJsonArrayAppendTool
-} from '../core.js';
-import type { MySQLAdapter } from '../../../MySQLAdapter.js';
-import { createMockMySQLAdapter, createMockRequestContext } from '../../../../../__tests__/mocks/index.js';
+  createMockMySQLAdapter,
+  createMockRequestContext,
+} from "../../../../../__tests__/mocks/index.js";
 
-describe('JSON Tool Validation', () => {
-    let mockAdapter: ReturnType<typeof createMockMySQLAdapter>;
-    let mockContext: ReturnType<typeof createMockRequestContext>;
+describe("JSON Tool Validation", () => {
+  let mockAdapter: ReturnType<typeof createMockMySQLAdapter>;
+  let mockContext: ReturnType<typeof createMockRequestContext>;
 
-    beforeEach(() => {
-        vi.clearAllMocks();
-        mockAdapter = createMockMySQLAdapter();
-        mockContext = createMockRequestContext();
-        // Mock success for valid queries
-        mockAdapter.executeWriteQuery.mockResolvedValue({
-            rowsAffected: 1,
-            insertId: 0
-        });
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mockAdapter = createMockMySQLAdapter();
+    mockContext = createMockRequestContext();
+    // Mock success for valid queries
+    mockAdapter.executeWriteQuery.mockResolvedValue({
+      rowsAffected: 1,
+      insertId: 0,
     });
+  });
 
-    describe('Validation Logic', () => {
-        it('should throw error for unquoted string "green"', async () => {
-            const tool = createJsonSetTool(mockAdapter as unknown as MySQLAdapter);
-            await expect(tool.handler({
-                table: 'data',
-                column: 'json_col',
-                path: '$.color',
-                value: 'green',
-                where: 'id = 1'
-            }, mockContext)).rejects.toThrow(/Invalid JSON value/);
-        });
+  describe("Validation Logic", () => {
+    it('should accept bare string "green" (auto-wrapped)', async () => {
+      const tool = createJsonSetTool(mockAdapter as unknown as MySQLAdapter);
+      // Bare strings are now auto-wrapped to valid JSON strings
+      await expect(
+        tool.handler(
+          {
+            table: "data",
+            column: "json_col",
+            path: "$.color",
+            value: "green",
+            where: "id = 1",
+          },
+          mockContext,
+        ),
+      ).resolves.not.toThrow();
+    });
 
-        it('should accept quoted string "\\"green\\""', async () => {
-            const tool = createJsonSetTool(mockAdapter as unknown as MySQLAdapter);
-            await expect(tool.handler({
-                table: 'data',
-                column: 'json_col',
-                path: '$.color',
-                value: '"green"',
-                where: 'id = 1'
-            }, mockContext)).resolves.not.toThrow();
-        });
+    it('should accept quoted string "\\"green\\""', async () => {
+      const tool = createJsonSetTool(mockAdapter as unknown as MySQLAdapter);
+      await expect(
+        tool.handler(
+          {
+            table: "data",
+            column: "json_col",
+            path: "$.color",
+            value: '"green"',
+            where: "id = 1",
+          },
+          mockContext,
+        ),
+      ).resolves.not.toThrow();
+    });
 
-        it('should accept numbers', async () => {
-            const tool = createJsonInsertTool(mockAdapter as unknown as MySQLAdapter);
-            await expect(tool.handler({
-                table: 'data',
-                column: 'json_col',
-                path: '$.count',
-                value: 42,
-                where: 'id = 1'
-            }, mockContext)).resolves.not.toThrow();
-        });
+    it("should accept numbers", async () => {
+      const tool = createJsonInsertTool(mockAdapter as unknown as MySQLAdapter);
+      await expect(
+        tool.handler(
+          {
+            table: "data",
+            column: "json_col",
+            path: "$.count",
+            value: 42,
+            where: "id = 1",
+          },
+          mockContext,
+        ),
+      ).resolves.not.toThrow();
+    });
 
-        it('should throw for invalid JSON object string', async () => {
-            const tool = createJsonReplaceTool(mockAdapter as unknown as MySQLAdapter);
-            await expect(tool.handler({
-                table: 'data',
-                column: 'json_col',
-                path: '$.obj',
-                value: '{key: "invalid"}', // Missing quotes on key
-                where: 'id = 1'
-            }, mockContext)).rejects.toThrow(/Invalid JSON value/);
-        });
+    it("should accept invalid JSON object string (auto-wrapped as string)", async () => {
+      const tool = createJsonReplaceTool(
+        mockAdapter as unknown as MySQLAdapter,
+      );
+      // Invalid JSON is now wrapped as a plain string, not rejected
+      await expect(
+        tool.handler(
+          {
+            table: "data",
+            column: "json_col",
+            path: "$.obj",
+            value: '{key: "invalid"}', // Treated as a string value
+            where: "id = 1",
+          },
+          mockContext,
+        ),
+      ).resolves.not.toThrow();
+    });
 
-        it('should validate array append values', async () => {
-            const tool = createJsonArrayAppendTool(mockAdapter as unknown as MySQLAdapter);
-            await expect(tool.handler({
-                table: 'data',
-                column: 'json_col',
-                path: '$',
-                value: 'invalid_string',
-                where: 'id = 1'
-            }, mockContext)).rejects.toThrow(/Invalid JSON value/);
-        });
+    it("should accept array append with bare string (auto-wrapped)", async () => {
+      const tool = createJsonArrayAppendTool(
+        mockAdapter as unknown as MySQLAdapter,
+      );
+      // Bare strings are now auto-wrapped
+      await expect(
+        tool.handler(
+          {
+            table: "data",
+            column: "json_col",
+            path: "$",
+            value: "auto_wrapped_string",
+            where: "id = 1",
+          },
+          mockContext,
+        ),
+      ).resolves.not.toThrow();
     });
+  });
 });