@neverinfamous/mysql-mcp 2.1.0

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

@@ -0,0 +1,316 @@
+/**
+ * mysql-mcp - JSON Enhanced Tools Unit Tests
+ * 
+ * Comprehensive tests for enhanced.ts module functions.
+ */
+
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import {
+    createJsonMergeTool,
+    createJsonDiffTool,
+    createJsonNormalizeTool,
+    createJsonStatsTool,
+    createJsonIndexSuggestTool
+} from '../enhanced.js';
+import type { MySQLAdapter } from '../../../MySQLAdapter.js';
+import { createMockMySQLAdapter, createMockRequestContext, createMockQueryResult } from '../../../../../__tests__/mocks/index.js';
+
+describe('JSON Enhanced Tools', () => {
+    let mockAdapter: ReturnType<typeof createMockMySQLAdapter>;
+    let mockContext: ReturnType<typeof createMockRequestContext>;
+
+    beforeEach(() => {
+        vi.clearAllMocks();
+        mockAdapter = createMockMySQLAdapter();
+        mockContext = createMockRequestContext();
+    });
+
+    describe('createJsonMergeTool', () => {
+        it('should merge JSON using patch mode', async () => {
+            mockAdapter.executeReadQuery.mockResolvedValue(createMockQueryResult([{ merged: '{"a":1}' }]));
+
+            const tool = createJsonMergeTool(mockAdapter as unknown as MySQLAdapter);
+            const result = await tool.handler({
+                json1: '{}',
+                json2: '{"a":1}',
+                mode: 'patch'
+            }, mockContext) as { merged: any };
+
+            expect(mockAdapter.executeReadQuery).toHaveBeenCalled();
+            const call = mockAdapter.executeReadQuery.mock.calls[0][0] as string;
+            expect(call).toContain('JSON_MERGE_PATCH');
+            expect(result.merged).toEqual({ a: 1 });
+        });
+
+        it('should merge JSON using preserve mode', async () => {
+            mockAdapter.executeReadQuery.mockResolvedValue(createMockQueryResult([{ merged: '[1, 2]' }]));
+
+            const tool = createJsonMergeTool(mockAdapter as unknown as MySQLAdapter);
+            await tool.handler({
+                json1: '[1]',
+                json2: '[2]',
+                mode: 'preserve'
+            }, mockContext);
+
+            const call = mockAdapter.executeReadQuery.mock.calls[0][0] as string;
+            expect(call).toContain('JSON_MERGE_PRESERVE');
+        });
+
+        it('should return object result directly if not string', async () => {
+            // When MySQL returns an object instead of JSON string (some drivers)
+            mockAdapter.executeReadQuery.mockResolvedValue(createMockQueryResult([{ merged: { direct: 'object' } }]));
+
+            const tool = createJsonMergeTool(mockAdapter as unknown as MySQLAdapter);
+            const result = await tool.handler({
+                json1: '{}',
+                json2: '{"direct": "object"}',
+                mode: 'patch'
+            }, mockContext) as { merged: any };
+
+            expect(result.merged).toEqual({ direct: 'object' });
+        });
+    });
+
+    describe('createJsonDiffTool', () => {
+        it('should compare JSON documents', async () => {
+            mockAdapter.executeReadQuery.mockResolvedValue(createMockQueryResult([{
+                identical: 1,
+                json1_contains_json2: 1,
+                json2_contains_json1: 1
+            }]));
+
+            const tool = createJsonDiffTool(mockAdapter as unknown as MySQLAdapter);
+            const result = await tool.handler({
+                json1: '{}',
+                json2: '{}'
+            }, mockContext) as { identical: boolean };
+
+            expect(mockAdapter.executeReadQuery).toHaveBeenCalled();
+            expect(result.identical).toBe(true);
+        });
+
+        it('should parse string keys into array', async () => {
+            mockAdapter.executeReadQuery.mockResolvedValue(createMockQueryResult([{
+                identical: 0,
+                json1_contains_json2: 0,
+                json2_contains_json1: 0,
+                json1_length: 2,
+                json2_length: 1,
+                json1_keys: '["a", "b"]',
+                json2_keys: '["c"]'
+            }]));
+
+            const tool = createJsonDiffTool(mockAdapter as unknown as MySQLAdapter);
+            const result = await tool.handler({
+                json1: '{"a":1,"b":2}',
+                json2: '{"c":3}'
+            }, mockContext) as { json1Keys: string[]; json2Keys: string[] };
+
+            expect(result.json1Keys).toEqual(['a', 'b']);
+            expect(result.json2Keys).toEqual(['c']);
+        });
+
+        it('should handle non-string keys (already parsed by driver)', async () => {
+            mockAdapter.executeReadQuery.mockResolvedValue(createMockQueryResult([{
+                identical: 0,
+                json1_keys: ['x', 'y'],
+                json2_keys: ['z']
+            }]));
+
+            const tool = createJsonDiffTool(mockAdapter as unknown as MySQLAdapter);
+            const result = await tool.handler({
+                json1: '{"x":1,"y":2}',
+                json2: '{"z":3}'
+            }, mockContext) as { json1Keys: string[]; json2Keys: string[] };
+
+            expect(result.json1Keys).toEqual(['x', 'y']);
+            expect(result.json2Keys).toEqual(['z']);
+        });
+    });
+
+    describe('createJsonNormalizeTool', () => {
+        it('should normalize JSON keys', async () => {
+            mockAdapter.executeQuery
+                .mockResolvedValueOnce(createMockQueryResult([{ key_name: 'k1' }, { key_name: 'k2' }])) // Keys
+                .mockResolvedValueOnce(createMockQueryResult([{ value_type: 'INTEGER', count: 10 }])) // k1 types
+                .mockResolvedValueOnce(createMockQueryResult([{ value_type: 'STRING', count: 5 }])); // k2 types
+
+            const tool = createJsonNormalizeTool(mockAdapter as unknown as MySQLAdapter);
+            const result = await tool.handler({
+                table: 'data',
+                column: 'json_col',
+                limit: 10
+            }, mockContext) as { uniqueKeys: string[] };
+
+            expect(mockAdapter.executeQuery).toHaveBeenCalledTimes(3);
+            expect(result.uniqueKeys).toEqual(['k1', 'k2']);
+        });
+
+        it('should include where clause in queries', async () => {
+            mockAdapter.executeQuery
+                .mockResolvedValueOnce(createMockQueryResult([{ key_name: 'k1' }]))
+                .mockResolvedValueOnce(createMockQueryResult([{ value_type: 'STRING', count: 1 }]));
+
+            const tool = createJsonNormalizeTool(mockAdapter as unknown as MySQLAdapter);
+            await tool.handler({
+                table: 'data',
+                column: 'json_col',
+                where: 'active = 1',
+                limit: 10
+            }, mockContext);
+
+            const keysQuery = mockAdapter.executeQuery.mock.calls[0][0] as string;
+            expect(keysQuery).toContain('WHERE active = 1');
+        });
+
+        it('should set truncated flag when more than 20 keys', async () => {
+            const manyKeys = Array.from({ length: 25 }, (_, i) => ({ key_name: `key${i}` }));
+            mockAdapter.executeQuery.mockResolvedValueOnce(createMockQueryResult(manyKeys));
+            // Mock type queries for first 20 keys
+            for (let i = 0; i < 20; i++) {
+                mockAdapter.executeQuery.mockResolvedValueOnce(createMockQueryResult([{ value_type: 'STRING', count: 1 }]));
+            }
+
+            const tool = createJsonNormalizeTool(mockAdapter as unknown as MySQLAdapter);
+            const result = await tool.handler({
+                table: 'data',
+                column: 'json_col',
+                limit: 100
+            }, mockContext) as { truncated: boolean; keyCount: number };
+
+            expect(result.truncated).toBe(true);
+            expect(result.keyCount).toBe(25);
+        });
+    });
+
+    describe('createJsonStatsTool', () => {
+        it('should calculate JSON stats', async () => {
+            mockAdapter.executeQuery.mockResolvedValue(createMockQueryResult([{
+                total_rows: 100,
+                null_count: 5,
+                avg_length: 10
+            }]));
+
+            const tool = createJsonStatsTool(mockAdapter as unknown as MySQLAdapter);
+            const result = await tool.handler({
+                table: 'data',
+                column: 'json_col'
+            }, mockContext) as { totalSampled: number };
+
+            expect(mockAdapter.executeQuery).toHaveBeenCalled();
+            expect(result.totalSampled).toBe(100);
+        });
+
+        it('should include where clause in stats query', async () => {
+            mockAdapter.executeQuery.mockResolvedValue(createMockQueryResult([{
+                total_rows: 50,
+                null_count: 2
+            }]));
+
+            const tool = createJsonStatsTool(mockAdapter as unknown as MySQLAdapter);
+            await tool.handler({
+                table: 'data',
+                column: 'json_col',
+                where: 'status = "active"'
+            }, mockContext);
+
+            const query = mockAdapter.executeQuery.mock.calls[0][0] as string;
+            expect(query).toContain('WHERE status = "active"');
+        });
+    });
+
+    describe('createJsonIndexSuggestTool', () => {
+        it('should suggest indexes for high cardinality keys', async () => {
+            mockAdapter.executeQuery
+                .mockResolvedValueOnce(createMockQueryResult([{ key_name: 'id' }, { key_name: 'type' }])) // Keys
+                .mockResolvedValueOnce(createMockQueryResult([{ value_type: 'INTEGER', cardinality: 50 }])) // id card
+                .mockResolvedValueOnce(createMockQueryResult([{ value_type: 'STRING', cardinality: 5 }])); // type card
+
+            const tool = createJsonIndexSuggestTool(mockAdapter as unknown as MySQLAdapter);
+            const result = await tool.handler({
+                table: 'data',
+                column: 'json_col'
+            }, mockContext) as { suggestions: any[] };
+
+            expect(mockAdapter.executeQuery).toHaveBeenCalledTimes(3);
+            expect(result.suggestions).toHaveLength(2);
+            expect(result.suggestions[0].path).toBe('$.id'); // higher cardinality first
+            expect(result.suggestions[0].indexDdl).toContain('BIGINT');
+        });
+
+        it('should use DOUBLE for double value types', async () => {
+            mockAdapter.executeQuery
+                .mockResolvedValueOnce(createMockQueryResult([{ key_name: 'price' }]))
+                .mockResolvedValueOnce(createMockQueryResult([{ value_type: 'DOUBLE', cardinality: 100 }]));
+
+            const tool = createJsonIndexSuggestTool(mockAdapter as unknown as MySQLAdapter);
+            const result = await tool.handler({
+                table: 'products',
+                column: 'data'
+            }, mockContext) as { suggestions: any[] };
+
+            expect(result.suggestions[0].indexDdl).toContain('DOUBLE');
+        });
+
+        it('should use TINYINT(1) for boolean value types', async () => {
+            mockAdapter.executeQuery
+                .mockResolvedValueOnce(createMockQueryResult([{ key_name: 'active' }]))
+                .mockResolvedValueOnce(createMockQueryResult([{ value_type: 'BOOLEAN', cardinality: 2 }]));
+
+            const tool = createJsonIndexSuggestTool(mockAdapter as unknown as MySQLAdapter);
+            const result = await tool.handler({
+                table: 'users',
+                column: 'settings'
+            }, mockContext) as { suggestions: any[] };
+
+            expect(result.suggestions[0].indexDdl).toContain('TINYINT(1)');
+        });
+
+        it('should skip keys with cardinality <= 1', async () => {
+            mockAdapter.executeQuery
+                .mockResolvedValueOnce(createMockQueryResult([{ key_name: 'constant' }]))
+                .mockResolvedValueOnce(createMockQueryResult([{ value_type: 'STRING', cardinality: 1 }]));
+
+            const tool = createJsonIndexSuggestTool(mockAdapter as unknown as MySQLAdapter);
+            const result = await tool.handler({
+                table: 'data',
+                column: 'json_col'
+            }, mockContext) as { suggestions: any[] };
+
+            expect(result.suggestions).toHaveLength(0);
+        });
+
+        it('should handle UNKNOWN type for undefined valueType', async () => {
+            mockAdapter.executeQuery
+                .mockResolvedValueOnce(createMockQueryResult([{ key_name: 'mystery' }]))
+                .mockResolvedValueOnce(createMockQueryResult([{ cardinality: 10 }])); // No value_type
+
+            const tool = createJsonIndexSuggestTool(mockAdapter as unknown as MySQLAdapter);
+            const result = await tool.handler({
+                table: 'data',
+                column: 'json_col'
+            }, mockContext) as { suggestions: any[] };
+
+            expect(result.suggestions[0].type).toBe('UNKNOWN');
+            expect(result.suggestions[0].indexDdl).toContain('VARCHAR(255)');
+        });
+
+        it('should limit suggestions to top 5', async () => {
+            const keys = Array.from({ length: 10 }, (_, i) => ({ key_name: `key${i}` }));
+            mockAdapter.executeQuery.mockResolvedValueOnce(createMockQueryResult(keys));
+            for (let i = 0; i < 10; i++) {
+                mockAdapter.executeQuery.mockResolvedValueOnce(createMockQueryResult([
+                    { value_type: 'STRING', cardinality: 100 - i * 10 }
+                ]));
+            }
+
+            const tool = createJsonIndexSuggestTool(mockAdapter as unknown as MySQLAdapter);
+            const result = await tool.handler({
+                table: 'data',
+                column: 'json_col'
+            }, mockContext) as { suggestions: any[] };
+
+            expect(result.suggestions).toHaveLength(5);
+        });
+    });
+});

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

@@ -0,0 +1,94 @@
+/**
+ * mysql-mcp - JSON Helper Tools Unit Tests
+ * 
+ * Comprehensive tests for helpers.ts module functions.
+ */
+
+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();
+    });
+
+    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('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);
+        });
+    });
+
+    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');
+        });
+    });
+
+    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 };
+
+            expect(mockAdapter.executeReadQuery).toHaveBeenCalled();
+            expect(result.valid).toBe(true);
+        });
+    });
+});

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

@@ -0,0 +1,83 @@
+
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import {
+    createJsonSetTool,
+    createJsonInsertTool,
+    createJsonReplaceTool,
+    createJsonArrayAppendTool
+} from '../core.js';
+import type { MySQLAdapter } from '../../../MySQLAdapter.js';
+import { createMockMySQLAdapter, createMockRequestContext } from '../../../../../__tests__/mocks/index.js';
+
+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
+        });
+    });
+
+    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/);
+        });
+
+        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 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 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/);
+        });
+    });
+});