@neverinfamous/mysql-mcp 2.1.0

package/src/adapters/mysql/tools/shell/__tests__/data-transfer.test.ts

@@ -0,0 +1,368 @@
+
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import * as child_process from 'child_process';
+import { createMockMySQLAdapter, createMockRequestContext } from '../../../../../__tests__/mocks/index.js';
+import {
+    createShellExportTableTool,
+    createShellImportTableTool,
+    createShellImportJSONTool
+} from '../data-transfer.js';
+
+vi.mock('child_process', () => ({
+    spawn: vi.fn()
+}));
+
+describe('Shell Data Transfer Tools', () => {
+    let mockAdapter: ReturnType<typeof createMockMySQLAdapter>;
+    let mockContext: ReturnType<typeof createMockRequestContext>;
+    let mockSpawn: ReturnType<typeof vi.fn>;
+
+    beforeEach(() => {
+        vi.clearAllMocks();
+        mockAdapter = createMockMySQLAdapter();
+        mockContext = createMockRequestContext();
+        mockSpawn = child_process.spawn as any;
+    });
+
+    afterEach(() => {
+        vi.restoreAllMocks();
+    });
+
+    function setupMockSpawn(stdout = '', stderr = '', exitCode = 0) {
+        const mockChild = {
+            stdout: {
+                on: vi.fn().mockImplementation((event, cb) => {
+                    if (event === 'data') cb(Buffer.from(stdout));
+                })
+            },
+            stderr: {
+                on: vi.fn().mockImplementation((event, cb) => {
+                    if (event === 'data') cb(Buffer.from(stderr));
+                })
+            },
+            stdin: {
+                write: vi.fn(),
+                end: vi.fn()
+            },
+            on: vi.fn().mockImplementation((event, cb) => {
+                if (event === 'close') cb(exitCode);
+            }),
+            kill: vi.fn()
+        };
+        mockSpawn.mockReturnValue(mockChild);
+        return mockChild;
+    }
+
+    describe('mysqlsh_export_table', () => {
+        it('should export table with CSV format and options', async () => {
+            const successJson = JSON.stringify({ success: true, result: { rows: 100 } });
+            setupMockSpawn(successJson);
+
+            const tool = createShellExportTableTool();
+            const result = await tool.handler({
+                schema: 'test',
+                table: 'users',
+                outputPath: '/tmp/dump',
+                format: 'csv'
+            }, mockContext) as any;
+
+            expect(result.success).toBe(true);
+            expect(result.result).toEqual({ rows: 100 });
+
+            const jsArg = mockSpawn.mock.calls[0][1][4];
+            expect(jsArg).toContain('util.exportTable("test.users"');
+            expect(jsArg).toContain('fieldsTerminatedBy: ","');
+            expect(jsArg).toContain('fieldsEnclosedBy: "\\""');
+        });
+
+        it('should export table with TSV format', async () => {
+            setupMockSpawn(JSON.stringify({ success: true }));
+
+            const tool = createShellExportTableTool();
+            await tool.handler({
+                schema: 'test',
+                table: 'users',
+                outputPath: '/tmp/dump.tsv',
+                format: 'tsv'
+            }, mockContext);
+
+            const jsArg = mockSpawn.mock.calls[0][1][4];
+            expect(jsArg).toContain('fieldsTerminatedBy: "\\t"');
+        });
+
+        it('should export table with WHERE clause', async () => {
+            setupMockSpawn(JSON.stringify({ success: true }));
+
+            const tool = createShellExportTableTool();
+            await tool.handler({
+                schema: 'test',
+                table: 'users',
+                outputPath: '/tmp/users_filtered',
+                format: 'json',
+                where: 'age > 18'
+            }, mockContext);
+
+            const jsArg = mockSpawn.mock.calls[0][1][4];
+            expect(jsArg).toContain('where: "age > 18"');
+        });
+
+        it('should escape backslashes in path', async () => {
+            setupMockSpawn(JSON.stringify({ success: true }));
+
+            const tool = createShellExportTableTool();
+            await tool.handler({
+                schema: 'test',
+                table: 'users',
+                outputPath: 'C:\\temp\\dump',
+                format: 'json'
+            }, mockContext);
+
+            const jsArg = mockSpawn.mock.calls[0][1][4];
+            // In JS code it should be escaped: C:\\temp\\dump
+            // So we look for "C:\\temp\\dump" in the string
+            expect(jsArg).toContain('C:\\\\temp\\\\dump');
+        });
+    });
+
+    describe('mysqlsh_import_table', () => {
+        it('should import table with options', async () => {
+            const successJson = JSON.stringify({ success: true, result: { status: 'Done' } });
+            setupMockSpawn(successJson);
+
+            const tool = createShellImportTableTool();
+            const result = await tool.handler({
+                schema: 'test',
+                table: 'users',
+                inputPath: '/tmp/data.csv',
+                threads: 4,
+                skipRows: 1,
+                fieldsTerminatedBy: ',',
+                linesTerminatedBy: '\n',
+                columns: ['id', 'name']
+            }, mockContext) as any;
+
+            expect(result.success).toBe(true);
+            const jsArg = mockSpawn.mock.calls[0][1][4];
+            expect(jsArg).toContain('util.importTable("/tmp/data.csv"');
+            expect(jsArg).toContain('threads: 4');
+            expect(jsArg).toContain('skipRows: 1');
+            expect(jsArg).toContain('fieldsTerminatedBy: ","');
+            expect(jsArg).toContain('linesTerminatedBy: "\\n"');
+            expect(jsArg).toContain('columns: ["id","name"]');
+        });
+
+        it('should enable local_infile when updateServerSettings is true', async () => {
+            const successJson = JSON.stringify({ success: true, result: { status: 'Done' } });
+            setupMockSpawn(successJson);
+
+            const tool = createShellImportTableTool();
+            const result = await tool.handler({
+                schema: 'test',
+                table: 'users',
+                inputPath: '/tmp/data.csv',
+                updateServerSettings: true
+            }, mockContext) as any;
+
+            expect(result.success).toBe(true);
+            expect(result.localInfileEnabled).toBe(true);
+
+            const jsArg = mockSpawn.mock.calls[0][1][4];
+            expect(jsArg).toContain('SET GLOBAL local_infile = ON');
+        });
+
+        it('should throw helpful error when local_infile is disabled', async () => {
+            setupMockSpawn('', 'ERROR: local_infile is disabled', 1);
+
+            const tool = createShellImportTableTool();
+            await expect(tool.handler({
+                schema: 'test',
+                table: 'users',
+                inputPath: '/tmp/data.csv'
+            }, mockContext)).rejects.toThrow('local_infile is disabled');
+        });
+
+        it('should throw helpful error when Loading local data is disabled', async () => {
+            setupMockSpawn('', 'Loading local data is disabled', 1);
+
+            const tool = createShellImportTableTool();
+            await expect(tool.handler({
+                schema: 'test',
+                table: 'users',
+                inputPath: '/tmp/data.csv'
+            }, mockContext)).rejects.toThrow('updateServerSettings: true');
+        });
+
+        it('should re-throw non-local_infile errors', async () => {
+            setupMockSpawn('', 'Some other error', 1);
+
+            const tool = createShellImportTableTool();
+            await expect(tool.handler({
+                schema: 'test',
+                table: 'users',
+                inputPath: '/tmp/data.csv'
+            }, mockContext)).rejects.toThrow('Some other error');
+        });
+    });
+
+    describe('mysqlsh_import_json', () => {
+        it('should import JSON to collection', async () => {
+            const successJson = JSON.stringify({ success: true, result: { imported: 50 } });
+            setupMockSpawn(successJson);
+
+            const tool = createShellImportJSONTool();
+            const result = await tool.handler({
+                inputPath: '/tmp/docs.json',
+                schema: 'test',
+                collection: 'docs'
+            }, mockContext) as any;
+
+            expect(result.success).toBe(true);
+            expect(result.protocol).toBe('X Protocol');
+
+            const jsArg = mockSpawn.mock.calls[0][1][4];
+            expect(jsArg).toContain('collection: "docs"');
+        });
+
+        it('should import JSON to table column with BSON types conversion', async () => {
+            const successJson = JSON.stringify({ success: true, result: { imported: 50 } });
+            setupMockSpawn(successJson);
+
+            const tool = createShellImportJSONTool();
+            await tool.handler({
+                inputPath: '/tmp/data.json',
+                schema: 'test',
+                collection: 'my_table', // 'collection' param is used as table name when tableColumn is present logic-wise?
+                // Wait, let's check source code logic. 
+                // if (tableColumn) { options.push(`table: "${collection}"`); options.push(`tableColumn: "${tableColumn}"`); }
+                // So yes, schema.collection maps to inputSchema 'collection' field which seems to be used as table name here.
+                tableColumn: 'data_col',
+                convertBsonTypes: true
+            }, mockContext);
+
+            const jsArg = mockSpawn.mock.calls[0][1][4];
+            expect(jsArg).toContain('table: "my_table"');
+            expect(jsArg).toContain('tableColumn: "data_col"');
+            expect(jsArg).toContain('convertBsonTypes: true');
+        });
+
+        it('should return raw output when no JSON found but exit code 0', async () => {
+            setupMockSpawn('Some non-JSON success output', '', 0);
+
+            const tool = createShellImportJSONTool();
+            const result = await tool.handler({
+                inputPath: '/tmp/docs.json',
+                schema: 'test',
+                collection: 'docs'
+            }, mockContext) as any;
+
+            expect(result.success).toBe(true);
+            expect(result.result.raw).toBe('Some non-JSON success output');
+        });
+
+        it('should handle import failure', async () => {
+            setupMockSpawn('Import failed', '', 1);
+
+            const tool = createShellImportJSONTool();
+            await expect(tool.handler({
+                inputPath: '/tmp/bad.json',
+                schema: 'test',
+                collection: 'docs'
+            }, mockContext)).rejects.toThrow('Import failed');
+        });
+
+        it('should throw X Protocol error when access denied in stderr', async () => {
+            setupMockSpawn('', 'Access denied for user', 0);
+
+            const tool = createShellImportJSONTool();
+            await expect(tool.handler({
+                inputPath: '/tmp/docs.json',
+                schema: 'test',
+                collection: 'docs'
+            }, mockContext)).rejects.toThrow('X Protocol authentication failed');
+        });
+
+        it('should throw X Protocol error when 1045 code in stderr', async () => {
+            setupMockSpawn('', 'MySQL Error 1045: Access denied', 0);
+
+            const tool = createShellImportJSONTool();
+            await expect(tool.handler({
+                inputPath: '/tmp/docs.json',
+                schema: 'test',
+                collection: 'docs'
+            }, mockContext)).rejects.toThrow('X Protocol authentication failed');
+        });
+
+        it('should throw error when JSON result has success: false', async () => {
+            setupMockSpawn(JSON.stringify({ success: false, error: 'Collection not found' }), '', 0);
+
+            const tool = createShellImportJSONTool();
+            await expect(tool.handler({
+                inputPath: '/tmp/docs.json',
+                schema: 'test',
+                collection: 'nonexistent'
+            }, mockContext)).rejects.toThrow('Collection not found');
+        });
+
+        it('should throw unknown error when success: false without error message', async () => {
+            setupMockSpawn(JSON.stringify({ success: false }), '', 0);
+
+            const tool = createShellImportJSONTool();
+            await expect(tool.handler({
+                inputPath: '/tmp/docs.json',
+                schema: 'test',
+                collection: 'docs'
+            }, mockContext)).rejects.toThrow('Unknown MySQL Shell error');
+        });
+
+        it('should skip lines that parse to invalid JSON and continue looking', async () => {
+            // First line is invalid JSON, second line is valid
+            setupMockSpawn('{ invalid }\n' + JSON.stringify({ success: true, result: 'ok' }), '', 0);
+
+            const tool = createShellImportJSONTool();
+            const result = await tool.handler({
+                inputPath: '/tmp/docs.json',
+                schema: 'test',
+                collection: 'docs'
+            }, mockContext) as any;
+
+            expect(result.success).toBe(true);
+            expect(result.result).toBe('ok');
+        });
+
+        it('should skip empty lines when parsing JSON', async () => {
+            setupMockSpawn('\n\n' + JSON.stringify({ success: true, result: 'data' }) + '\n\n', '', 0);
+
+            const tool = createShellImportJSONTool();
+            const result = await tool.handler({
+                inputPath: '/tmp/docs.json',
+                schema: 'test',
+                collection: 'docs'
+            }, mockContext) as any;
+
+            expect(result.success).toBe(true);
+            expect(result.result).toBe('data');
+        });
+
+        it('should throw stderr message when failed with non-zero exit code', async () => {
+            setupMockSpawn('', 'Fatal shell error', 1);
+
+            const tool = createShellImportJSONTool();
+            await expect(tool.handler({
+                inputPath: '/tmp/bad.json',
+                schema: 'test',
+                collection: 'docs'
+            }, mockContext)).rejects.toThrow('Fatal shell error');
+        });
+
+        it('should throw stdout when no stderr on failure', async () => {
+            setupMockSpawn('stdout error message only', '', 1);
+
+            const tool = createShellImportJSONTool();
+            await expect(tool.handler({
+                inputPath: '/tmp/bad.json',
+                schema: 'test',
+                collection: 'docs'
+            }, mockContext)).rejects.toThrow('stdout error message only');
+        });
+    });
+});

package/src/adapters/mysql/tools/shell/__tests__/info.test.ts

@@ -0,0 +1,77 @@
+
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import * as child_process from 'child_process';
+import { createMockMySQLAdapter, createMockRequestContext } from '../../../../../__tests__/mocks/index.js';
+import { createShellVersionTool } from '../info.js';
+
+vi.mock('child_process', () => ({
+    spawn: vi.fn()
+}));
+
+describe('Shell Info Tools', () => {
+    let mockAdapter: ReturnType<typeof createMockMySQLAdapter>;
+    let mockContext: ReturnType<typeof createMockRequestContext>;
+    let mockSpawn: ReturnType<typeof vi.fn>;
+
+    beforeEach(() => {
+        vi.clearAllMocks();
+        mockAdapter = createMockMySQLAdapter();
+        mockContext = createMockRequestContext();
+        mockSpawn = child_process.spawn as any;
+    });
+
+    afterEach(() => {
+        vi.restoreAllMocks();
+    });
+
+    function setupMockSpawn(stdout = '', stderr = '', exitCode = 0) {
+        const mockChild = {
+            stdout: {
+                on: vi.fn().mockImplementation((event, cb) => {
+                    if (event === 'data') cb(Buffer.from(stdout));
+                })
+            },
+            stderr: {
+                on: vi.fn().mockImplementation((event, cb) => {
+                    if (event === 'data') cb(Buffer.from(stderr));
+                })
+            },
+            stdin: {
+                write: vi.fn(),
+                end: vi.fn()
+            },
+            on: vi.fn().mockImplementation((event, cb) => {
+                if (event === 'close') cb(exitCode);
+            }),
+            kill: vi.fn()
+        };
+        mockSpawn.mockReturnValue(mockChild);
+        return mockChild;
+    }
+
+    describe('mysqlsh_version', () => {
+        it('should return version info', async () => {
+            setupMockSpawn('mysqlsh   Ver 8.0.35 for Linux on x86_64');
+
+            const tool = createShellVersionTool();
+            const result = await tool.handler({}, mockContext) as any;
+
+            expect(result.success).toBe(true);
+            expect(result.version).toBe('8.0.35');
+            expect(child_process.spawn).toHaveBeenCalledWith(
+                'mysqlsh',
+                ['--version'],
+                expect.any(Object)
+            );
+        });
+
+        it('should handle unknown version format', async () => {
+            setupMockSpawn('Some other output');
+
+            const tool = createShellVersionTool();
+            const result = await tool.handler({}, mockContext) as any;
+
+            expect(result.version).toBe('unknown');
+        });
+    });
+});

package/src/adapters/mysql/tools/shell/__tests__/restore.test.ts

@@ -0,0 +1,187 @@
+
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import * as child_process from 'child_process';
+import { createMockMySQLAdapter, createMockRequestContext } from '../../../../../__tests__/mocks/index.js';
+import {
+    createShellLoadDumpTool,
+    createShellRunScriptTool
+} from '../restore.js';
+
+vi.mock('child_process', () => ({
+    spawn: vi.fn()
+}));
+
+describe('Shell Restore and Script Tools', () => {
+    let mockAdapter: ReturnType<typeof createMockMySQLAdapter>;
+    let mockContext: ReturnType<typeof createMockRequestContext>;
+    let mockSpawn: ReturnType<typeof vi.fn>;
+
+    beforeEach(() => {
+        vi.clearAllMocks();
+        mockAdapter = createMockMySQLAdapter();
+        mockContext = createMockRequestContext();
+        mockSpawn = child_process.spawn as any;
+    });
+
+    afterEach(() => {
+        vi.restoreAllMocks();
+    });
+
+    function setupMockSpawn(stdout = '', stderr = '', exitCode = 0) {
+        const mockChild = {
+            stdout: {
+                on: vi.fn().mockImplementation((event, cb) => {
+                    if (event === 'data') cb(Buffer.from(stdout));
+                })
+            },
+            stderr: {
+                on: vi.fn().mockImplementation((event, cb) => {
+                    if (event === 'data') cb(Buffer.from(stderr));
+                })
+            },
+            stdin: {
+                write: vi.fn(),
+                end: vi.fn()
+            },
+            on: vi.fn().mockImplementation((event, cb) => {
+                if (event === 'close') cb(exitCode);
+            }),
+            kill: vi.fn()
+        };
+        mockSpawn.mockReturnValue(mockChild);
+        return mockChild;
+    }
+
+    describe('mysqlsh_load_dump', () => {
+        it('should load dump with options', async () => {
+            const successJson = JSON.stringify({ success: true, result: { status: 'Completed' } });
+            setupMockSpawn(successJson);
+
+            const tool = createShellLoadDumpTool();
+            const result = await tool.handler({
+                inputDir: '/backup/full',
+                ignoreVersion: true,
+                resetProgress: true
+            }, mockContext) as any;
+
+            expect(result.success).toBe(true);
+
+            const jsArg = mockSpawn.mock.calls[0][1][4];
+            expect(jsArg).toContain('util.loadDump("/backup/full"');
+            expect(jsArg).toContain('ignoreVersion: true');
+            expect(jsArg).toContain('resetProgress: true');
+        });
+
+        it('should support all optional parameters', async () => {
+            setupMockSpawn(JSON.stringify({ success: true }));
+            const tool = createShellLoadDumpTool();
+            await tool.handler({
+                inputDir: '/in',
+                threads: 4,
+                dryRun: true,
+                includeSchemas: ['s1'],
+                excludeSchemas: ['s2'],
+                includeTables: ['t1'],
+                excludeTables: ['t2'],
+                ignoreExistingObjects: true
+            }, mockContext);
+
+            const jsArg = mockSpawn.mock.calls[0][1][4];
+            expect(jsArg).toContain('threads: 4');
+            expect(jsArg).toContain('dryRun: true');
+            expect(jsArg).toContain('includeSchemas: ["s1"]');
+            expect(jsArg).toContain('excludeSchemas: ["s2"]');
+            expect(jsArg).toContain('includeTables: ["t1"]');
+            expect(jsArg).toContain('excludeTables: ["t2"]');
+            expect(jsArg).toContain('ignoreExistingObjects: true');
+        });
+
+        it('should enable local_infile when updateServerSettings is true', async () => {
+            setupMockSpawn(JSON.stringify({ success: true }));
+            const tool = createShellLoadDumpTool();
+            const result = await tool.handler({
+                inputDir: '/backup',
+                updateServerSettings: true
+            }, mockContext) as any;
+
+            expect(result.success).toBe(true);
+            expect(result.localInfileEnabled).toBe(true);
+
+            const jsArg = mockSpawn.mock.calls[0][1][4];
+            expect(jsArg).toContain('SET GLOBAL local_infile = ON');
+        });
+
+        it('should throw helpful error when local_infile is disabled', async () => {
+            setupMockSpawn('', 'ERROR: local_infile is disabled', 1);
+
+            const tool = createShellLoadDumpTool();
+            await expect(tool.handler({
+                inputDir: '/backup'
+            }, mockContext)).rejects.toThrow('local_infile is disabled');
+        });
+
+        it('should throw helpful error when Loading local data is disabled', async () => {
+            setupMockSpawn('', 'Loading local data is disabled on the server', 1);
+
+            const tool = createShellLoadDumpTool();
+            await expect(tool.handler({
+                inputDir: '/backup'
+            }, mockContext)).rejects.toThrow('updateServerSettings: true');
+        });
+
+        it('should re-throw non-local_infile errors', async () => {
+            setupMockSpawn('', 'Schema already exists', 1);
+
+            const tool = createShellLoadDumpTool();
+            await expect(tool.handler({
+                inputDir: '/backup'
+            }, mockContext)).rejects.toThrow('Schema already exists');
+        });
+    });
+
+    describe('mysqlsh_run_script', () => {
+        it('should run javascript script', async () => {
+            setupMockSpawn('Script output');
+
+            const tool = createShellRunScriptTool();
+            const result = await tool.handler({
+                script: 'print("hello")',
+                language: 'js'
+            }, mockContext) as any;
+
+            expect(result.success).toBe(true);
+            expect(result.stdout).toBe('Script output');
+
+            const args = mockSpawn.mock.calls[0][1];
+            expect(args).toContain('--js');
+        });
+
+        it('should run python script', async () => {
+            setupMockSpawn('Python output');
+
+            const tool = createShellRunScriptTool();
+            const result = await tool.handler({
+                script: 'print("hello")',
+                language: 'py'
+            }, mockContext) as any;
+
+            expect(result.success).toBe(true);
+            const args = mockSpawn.mock.calls[0][1];
+            expect(args).toContain('--py');
+        });
+
+        it('should run sql script', async () => {
+            setupMockSpawn('SQL output');
+
+            const tool = createShellRunScriptTool();
+            const result = await tool.handler({
+                script: 'SELECT 1',
+                language: 'sql'
+            }, mockContext) as any;
+
+            expect(result.success).toBe(true);
+            const args = mockSpawn.mock.calls[0][1];
+            expect(args).toContain('--sql');
+        });
+    });
+});