@neverinfamous/mysql-mcp 2.1.0

package/src/adapters/mysql/tools/events.ts

@@ -0,0 +1,419 @@
+/**
+ * MySQL Event Scheduler Tools
+ * 
+ * Tools for managing MySQL's built-in Event Scheduler.
+ * 6 tools total.
+ */
+
+
+
+
+import { z } from 'zod';
+import type { MySQLAdapter } from '../MySQLAdapter.js';
+import type { ToolDefinition, RequestContext } from '../../../types/index.js';
+
+// =============================================================================
+// Zod Schemas
+// =============================================================================
+
+const EventCreateSchema = z.object({
+    name: z.string().describe('Event name'),
+    schedule: z.object({
+        type: z.enum(['ONE TIME', 'RECURRING']).describe('Event schedule type'),
+        executeAt: z.string().optional().describe('For ONE TIME: timestamp to execute (e.g., "2024-12-31 23:59:59")'),
+        interval: z.number().optional().describe('For RECURRING: interval value'),
+        intervalUnit: z.enum(['YEAR', 'QUARTER', 'MONTH', 'DAY', 'HOUR', 'MINUTE', 'WEEK', 'SECOND']).optional().describe('For RECURRING: interval unit'),
+        starts: z.string().optional().describe('For RECURRING: start timestamp'),
+        ends: z.string().optional().describe('For RECURRING: end timestamp')
+    }).describe('Event schedule configuration'),
+    body: z.string().describe('SQL statement(s) to execute'),
+    onCompletion: z.enum(['PRESERVE', 'NOT PRESERVE']).default('NOT PRESERVE').describe('What to do after event completes'),
+    enabled: z.boolean().default(true).describe('Whether event is enabled'),
+    comment: z.string().optional().describe('Event comment'),
+    ifNotExists: z.boolean().default(false).describe('Add IF NOT EXISTS clause')
+});
+
+const EventAlterSchema = z.object({
+    name: z.string().describe('Event name'),
+    newName: z.string().optional().describe('New event name (for rename)'),
+    schedule: z.object({
+        type: z.enum(['ONE TIME', 'RECURRING']).optional(),
+        executeAt: z.string().optional(),
+        interval: z.number().optional(),
+        intervalUnit: z.enum(['YEAR', 'QUARTER', 'MONTH', 'DAY', 'HOUR', 'MINUTE', 'WEEK', 'SECOND']).optional(),
+        starts: z.string().optional(),
+        ends: z.string().optional()
+    }).optional().describe('New schedule configuration'),
+    body: z.string().optional().describe('New SQL statement(s)'),
+    onCompletion: z.enum(['PRESERVE', 'NOT PRESERVE']).optional(),
+    enabled: z.boolean().optional().describe('Enable or disable event'),
+    comment: z.string().optional()
+});
+
+const EventDropSchema = z.object({
+    name: z.string().describe('Event name to drop'),
+    ifExists: z.boolean().default(true).describe('Add IF EXISTS clause')
+});
+
+const EventListSchema = z.object({
+    schema: z.string().optional().describe('Schema name (defaults to current database)'),
+    includeDisabled: z.boolean().default(true).describe('Include disabled events')
+});
+
+const EventStatusSchema = z.object({
+    name: z.string().describe('Event name'),
+    schema: z.string().optional().describe('Schema name (defaults to current database)')
+});
+
+/**
+ * Get all event scheduler tools
+ */
+export function getEventTools(adapter: MySQLAdapter): ToolDefinition[] {
+    return [
+        createEventCreateTool(adapter),
+        createEventAlterTool(adapter),
+        createEventDropTool(adapter),
+        createEventListTool(adapter),
+        createEventStatusTool(adapter),
+        createSchedulerStatusTool(adapter)
+    ];
+}
+
+/**
+ * Create a scheduled event
+ */
+function createEventCreateTool(adapter: MySQLAdapter): ToolDefinition {
+    return {
+        name: 'mysql_event_create',
+        title: 'MySQL Create Event',
+        description: 'Create a scheduled event (one-time or recurring) to execute SQL at specified times.',
+        group: 'events',
+        inputSchema: EventCreateSchema,
+        requiredScopes: ['admin'],
+        annotations: {
+            readOnlyHint: false
+        },
+        handler: async (params: unknown, _context: RequestContext) => {
+            const { name, schedule, body, onCompletion, enabled, comment, ifNotExists } = EventCreateSchema.parse(params);
+
+            // Validate event name
+            if (!/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(name)) {
+                throw new Error('Invalid event name');
+            }
+
+            const ifNotExistsClause = ifNotExists ? 'IF NOT EXISTS ' : '';
+            let sql = `CREATE EVENT ${ifNotExistsClause}\`${name}\`\nON SCHEDULE `;
+
+            // Build schedule clause
+            if (schedule.type === 'ONE TIME') {
+                if (!schedule.executeAt) {
+                    throw new Error('executeAt is required for ONE TIME events');
+                }
+                sql += `AT '${schedule.executeAt}'`;
+            } else {
+                if (schedule.interval === undefined || schedule.interval === null || schedule.intervalUnit === undefined || schedule.intervalUnit === null) {
+                    throw new Error('interval and intervalUnit are required for RECURRING events');
+                }
+                sql += `EVERY ${String(schedule.interval)} ${schedule.intervalUnit}`;
+                if (schedule.starts) {
+                    sql += ` STARTS '${schedule.starts}'`;
+                }
+                if (schedule.ends) {
+                    sql += ` ENDS '${schedule.ends}'`;
+                }
+            }
+
+            sql += `\nON COMPLETION ${onCompletion}`;
+
+            if (!enabled) {
+                sql += '\nDISABLE';
+            } else {
+                sql += '\nENABLE';
+            }
+
+            if (comment) {
+                sql += `\nCOMMENT '${comment.replace(/'/g, "''")}'`;
+            }
+
+            sql += `\nDO ${body}`;
+
+            await adapter.executeQuery(sql);
+            return { success: true, eventName: name };
+        }
+    };
+}
+
+/**
+ * Alter a scheduled event
+ */
+function createEventAlterTool(adapter: MySQLAdapter): ToolDefinition {
+    return {
+        name: 'mysql_event_alter',
+        title: 'MySQL Alter Event',
+        description: 'Modify an existing scheduled event schedule, body, or status.',
+        group: 'events',
+        inputSchema: EventAlterSchema,
+        requiredScopes: ['admin'],
+        annotations: {
+            readOnlyHint: false
+        },
+        handler: async (params: unknown, _context: RequestContext) => {
+            const { name, newName, schedule, body, onCompletion, enabled, comment } = EventAlterSchema.parse(params);
+
+            // Validate event name
+            if (!/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(name)) {
+                throw new Error('Invalid event name');
+            }
+
+            let sql = `ALTER EVENT \`${name}\``;
+            const clauses: string[] = [];
+
+            // Build schedule clause if provided
+            if (schedule?.type) {
+                let scheduleClause = 'ON SCHEDULE ';
+                if (schedule.type === 'ONE TIME') {
+                    if (!schedule.executeAt) {
+                        throw new Error('executeAt is required for ONE TIME events');
+                    }
+                    scheduleClause += `AT '${schedule.executeAt}'`;
+                } else {
+                    if (schedule.interval === undefined || schedule.interval === null || schedule.intervalUnit === undefined || schedule.intervalUnit === null) {
+                        throw new Error('interval and intervalUnit are required for RECURRING events');
+                    }
+                    scheduleClause += `EVERY ${String(schedule.interval)} ${schedule.intervalUnit}`;
+                    if (schedule.starts) {
+                        scheduleClause += ` STARTS '${schedule.starts}'`;
+                    }
+                    if (schedule.ends) {
+                        scheduleClause += ` ENDS '${schedule.ends}'`;
+                    }
+                }
+                clauses.push(scheduleClause);
+            }
+
+            if (onCompletion) {
+                clauses.push(`ON COMPLETION ${onCompletion}`);
+            }
+
+            if (enabled !== undefined) {
+                clauses.push(enabled ? 'ENABLE' : 'DISABLE');
+            }
+
+            if (comment !== undefined) {
+                clauses.push(`COMMENT '${comment.replace(/'/g, "''")}'`);
+            }
+
+            if (body) {
+                clauses.push(`DO ${body}`);
+            }
+
+            if (newName) {
+                if (!/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(newName)) {
+                    throw new Error('Invalid new event name');
+                }
+                clauses.push(`RENAME TO \`${newName}\``);
+            }
+
+            if (clauses.length === 0) {
+                throw new Error('No modifications specified');
+            }
+
+            sql += '\n' + clauses.join('\n');
+
+            await adapter.executeQuery(sql);
+            return { success: true, eventName: newName ?? name };
+        }
+    };
+}
+
+/**
+ * Drop a scheduled event
+ */
+function createEventDropTool(adapter: MySQLAdapter): ToolDefinition {
+    return {
+        name: 'mysql_event_drop',
+        title: 'MySQL Drop Event',
+        description: 'Remove a scheduled event.',
+        group: 'events',
+        inputSchema: EventDropSchema,
+        requiredScopes: ['admin'],
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: true
+        },
+        handler: async (params: unknown, _context: RequestContext) => {
+            const { name, ifExists } = EventDropSchema.parse(params);
+
+            // Validate event name
+            if (!/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(name)) {
+                throw new Error('Invalid event name');
+            }
+
+            const ifExistsClause = ifExists ? 'IF EXISTS ' : '';
+            await adapter.executeQuery(`DROP EVENT ${ifExistsClause}\`${name}\``);
+
+            return { success: true, eventName: name };
+        }
+    };
+}
+
+/**
+ * List all events
+ */
+function createEventListTool(adapter: MySQLAdapter): ToolDefinition {
+    return {
+        name: 'mysql_event_list',
+        title: 'MySQL List Events',
+        description: 'List all scheduled events with status, schedule, and execution info.',
+        group: 'events',
+        inputSchema: EventListSchema,
+        requiredScopes: ['read'],
+        annotations: {
+            readOnlyHint: true,
+            idempotentHint: true
+        },
+        handler: async (params: unknown, _context: RequestContext) => {
+            const { schema, includeDisabled } = EventListSchema.parse(params);
+
+            let query = `
+                SELECT 
+                    EVENT_NAME as name,
+                    EVENT_SCHEMA as schemaName,
+                    DEFINER as definer,
+                    EVENT_TYPE as eventType,
+                    EXECUTE_AT as executeAt,
+                    INTERVAL_VALUE as intervalValue,
+                    INTERVAL_FIELD as intervalField,
+                    STARTS as starts,
+                    ENDS as ends,
+                    STATUS as status,
+                    ON_COMPLETION as onCompletion,
+                    LAST_EXECUTED as lastExecuted,
+                    EVENT_COMMENT as comment
+                FROM information_schema.EVENTS
+                WHERE EVENT_SCHEMA = COALESCE(?, DATABASE())
+            `;
+
+            const queryParams: unknown[] = [schema ?? null];
+
+            if (!includeDisabled) {
+                query += " AND STATUS = 'ENABLED'";
+            }
+
+            query += ' ORDER BY EVENT_NAME';
+
+            const result = await adapter.executeQuery(query, queryParams);
+            return {
+                events: result.rows,
+                count: result.rows?.length ?? 0
+            };
+        }
+    };
+}
+
+/**
+ * Get detailed event status
+ */
+function createEventStatusTool(adapter: MySQLAdapter): ToolDefinition {
+    return {
+        name: 'mysql_event_status',
+        title: 'MySQL Event Status',
+        description: 'Get detailed status and execution history for a specific event.',
+        group: 'events',
+        inputSchema: EventStatusSchema,
+        requiredScopes: ['read'],
+        annotations: {
+            readOnlyHint: true,
+            idempotentHint: true
+        },
+        handler: async (params: unknown, _context: RequestContext) => {
+            const { name, schema } = EventStatusSchema.parse(params);
+
+            const query = `
+                SELECT 
+                    EVENT_NAME as name,
+                    EVENT_SCHEMA as schemaName,
+                    DEFINER as definer,
+                    TIME_ZONE as timeZone,
+                    EVENT_TYPE as eventType,
+                    EXECUTE_AT as executeAt,
+                    INTERVAL_VALUE as intervalValue,
+                    INTERVAL_FIELD as intervalField,
+                    STARTS as starts,
+                    ENDS as ends,
+                    STATUS as status,
+                    ON_COMPLETION as onCompletion,
+                    CREATED as created,
+                    LAST_ALTERED as lastAltered,
+                    LAST_EXECUTED as lastExecuted,
+                    EVENT_COMMENT as comment,
+                    EVENT_DEFINITION as definition
+                FROM information_schema.EVENTS
+                WHERE EVENT_SCHEMA = COALESCE(?, DATABASE())
+                  AND EVENT_NAME = ?
+            `;
+
+            const result = await adapter.executeQuery(query, [schema ?? null, name]);
+
+            if (!result.rows || result.rows.length === 0) {
+                throw new Error(`Event '${name}' not found`);
+            }
+
+            return result.rows[0];
+        }
+    };
+}
+
+/**
+ * Get Event Scheduler global status
+ */
+function createSchedulerStatusTool(adapter: MySQLAdapter): ToolDefinition {
+    return {
+        name: 'mysql_scheduler_status',
+        title: 'MySQL Scheduler Status',
+        description: 'Get the global Event Scheduler status and event statistics.',
+        group: 'events',
+        inputSchema: z.object({}),
+        requiredScopes: ['read'],
+        annotations: {
+            readOnlyHint: true,
+            idempotentHint: true
+        },
+        handler: async (_params: unknown, _context: RequestContext) => {
+            // Get scheduler status
+            const statusResult = await adapter.executeQuery(
+                "SHOW VARIABLES LIKE 'event_scheduler'"
+            );
+
+            // Get event counts by status
+            const countResult = await adapter.executeQuery(`
+                SELECT 
+                    STATUS as status,
+                    COUNT(*) as count
+                FROM information_schema.EVENTS
+                GROUP BY STATUS
+            `);
+
+            // Get recently executed events
+            const recentResult = await adapter.executeQuery(`
+                SELECT 
+                    EVENT_NAME as name,
+                    EVENT_SCHEMA as schemaName,
+                    LAST_EXECUTED as lastExecuted
+                FROM information_schema.EVENTS
+                WHERE LAST_EXECUTED IS NOT NULL
+                ORDER BY LAST_EXECUTED DESC
+                LIMIT 10
+            `);
+
+            const schedulerStatus = statusResult.rows?.[0];
+
+            return {
+                schedulerEnabled: schedulerStatus?.['Value'] === 'ON',
+                schedulerStatus: schedulerStatus?.['Value'] ?? 'UNKNOWN',
+                eventCounts: countResult.rows ?? [],
+                recentlyExecuted: recentResult.rows ?? []
+            };
+        }
+    };
+}

package/src/adapters/mysql/tools/index.ts

@@ -0,0 +1,60 @@
+/**
+ * MySQL Adapter Tools - Index
+ * 
+ * Aggregates all tool exports for the MySQL adapter.
+ */
+
+// Core tools
+export { getCoreTools } from './core.js';
+
+// Transaction tools
+export { getTransactionTools } from './transactions.js';
+
+// JSON tools
+export { getJsonTools, getJsonHelperTools, getJsonEnhancedTools } from './json/index.js';
+
+// Text and fulltext tools
+export { getTextTools, getFulltextTools } from './text/index.js';
+
+// Performance and optimization tools
+export { getPerformanceTools, getOptimizationTools } from './performance/index.js';
+
+// Admin, monitoring, and backup tools
+export { getAdminTools, getMonitoringTools, getBackupTools } from './admin/index.js';
+
+// Replication and partitioning tools
+export { getReplicationTools } from './replication.js';
+export { getPartitioningTools } from './partitioning.js';
+
+// Router management tools
+export { getRouterTools } from './router.js';
+
+// ProxySQL management tools
+export { getProxySQLTools } from './proxysql.js';
+
+// Schema management tools
+export { getSchemaTools } from './schema/index.js';
+
+// Event scheduler tools
+export { getEventTools } from './events.js';
+
+// sys schema tools
+export { getSysSchemaTools } from './sysschema/index.js';
+
+// Statistics tools
+export { getStatsTools } from './stats/index.js';
+
+// Spatial/GIS tools
+export { getSpatialTools } from './spatial/index.js';
+
+// Security tools
+export { getSecurityTools } from './security/index.js';
+
+// Cluster/Group Replication tools
+export { getClusterTools } from './cluster/index.js';
+
+// Role management tools
+export { getRoleTools } from './roles.js';
+
+// Document Store tools
+export { getDocStoreTools } from './docstore.js';

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

@@ -0,0 +1,207 @@
+/**
+ * mysql-mcp - JSON Core Tools Unit Tests
+ * 
+ * Comprehensive tests for core.ts module functions.
+ */
+
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import {
+    createJsonExtractTool,
+    createJsonSetTool,
+    createJsonInsertTool,
+    createJsonReplaceTool,
+    createJsonRemoveTool,
+    createJsonContainsTool,
+    createJsonKeysTool,
+    createJsonArrayAppendTool
+} from '../core.js';
+import type { MySQLAdapter } from '../../../MySQLAdapter.js';
+import { createMockMySQLAdapter, createMockRequestContext, createMockQueryResult } from '../../../../../__tests__/mocks/index.js';
+
+describe('JSON Core Tools', () => {
+    let mockAdapter: ReturnType<typeof createMockMySQLAdapter>;
+    let mockContext: ReturnType<typeof createMockRequestContext>;
+
+    beforeEach(() => {
+        vi.clearAllMocks();
+        mockAdapter = createMockMySQLAdapter();
+        mockContext = createMockRequestContext();
+    });
+
+    describe('createJsonExtractTool', () => {
+        it('should extract JSON value', async () => {
+            mockAdapter.executeReadQuery.mockResolvedValue(createMockQueryResult([{ extracted_value: 'value' }]));
+
+            const tool = createJsonExtractTool(mockAdapter as unknown as MySQLAdapter);
+            const result = await tool.handler({
+                table: 'data',
+                column: 'json_col',
+                path: '$.key'
+            }, mockContext) as { rows: unknown[] };
+
+            expect(mockAdapter.executeReadQuery).toHaveBeenCalled();
+            const call = mockAdapter.executeReadQuery.mock.calls[0][0] as string;
+            expect(call).toContain('JSON_EXTRACT(`json_col`, ?)');
+            expect(result.rows).toHaveLength(1);
+        });
+    });
+
+    describe('createJsonSetTool', () => {
+        it('should set JSON value', async () => {
+            mockAdapter.executeWriteQuery.mockResolvedValue({
+                rowsAffected: 1,
+                insertId: 0
+            });
+
+            const tool = createJsonSetTool(mockAdapter as unknown as MySQLAdapter);
+            const result = await tool.handler({
+                table: 'data',
+                column: 'json_col',
+                path: '$.key',
+                value: '"new_value"',
+                where: 'id = 1'
+            }, mockContext) as { rowsAffected: number };
+
+            expect(mockAdapter.executeWriteQuery).toHaveBeenCalled();
+            const call = mockAdapter.executeWriteQuery.mock.calls[0][0] as string;
+            expect(call).toContain('JSON_SET');
+            expect(result.rowsAffected).toBe(1);
+        });
+
+        it('should stringify object value', async () => {
+            const tool = createJsonSetTool(mockAdapter as unknown as MySQLAdapter);
+            await tool.handler({
+                table: 'data',
+                column: 'json_col',
+                path: '$.key',
+                value: { foo: 'bar' },
+                where: 'id = 1'
+            }, mockContext);
+
+            const args = mockAdapter.executeWriteQuery.mock.calls[0][1] as unknown[];
+            expect(args[1]).toBe('{"foo":"bar"}');
+        });
+    });
+
+    describe('createJsonInsertTool', () => {
+        it('should insert JSON value', async () => {
+            mockAdapter.executeWriteQuery.mockResolvedValue({ rowsAffected: 1, insertId: 0 });
+
+            const tool = createJsonInsertTool(mockAdapter as unknown as MySQLAdapter);
+            await tool.handler({
+                table: 'data',
+                column: 'json_col',
+                path: '$.key',
+                value: '"new_value"',
+                where: 'id = 1'
+            }, mockContext);
+
+            const call = mockAdapter.executeWriteQuery.mock.calls[0][0] as string;
+            expect(call).toContain('JSON_INSERT');
+        });
+    });
+
+    describe('createJsonReplaceTool', () => {
+        it('should replace JSON value', async () => {
+            mockAdapter.executeWriteQuery.mockResolvedValue({ rowsAffected: 1, insertId: 0 });
+
+            const tool = createJsonReplaceTool(mockAdapter as unknown as MySQLAdapter);
+            await tool.handler({
+                table: 'data',
+                column: 'json_col',
+                path: '$.key',
+                value: '"new_value"',
+                where: 'id = 1'
+            }, mockContext);
+
+            const call = mockAdapter.executeWriteQuery.mock.calls[0][0] as string;
+            expect(call).toContain('JSON_REPLACE');
+        });
+    });
+
+    describe('createJsonRemoveTool', () => {
+        it('should remove JSON paths', async () => {
+            mockAdapter.executeWriteQuery.mockResolvedValue({ rowsAffected: 1, insertId: 0 });
+
+            const tool = createJsonRemoveTool(mockAdapter as unknown as MySQLAdapter);
+            await tool.handler({
+                table: 'data',
+                column: 'json_col',
+                paths: ['$.k1', '$.k2'],
+                where: 'id = 1'
+            }, mockContext);
+
+            const call = mockAdapter.executeWriteQuery.mock.calls[0][0] as string;
+            expect(call).toContain('JSON_REMOVE');
+            // Should contain multiple ? based on paths length
+            // Implementation: JSON_REMOVE(\`json_col\`, ?, ?)
+        });
+    });
+
+    describe('createJsonContainsTool', () => {
+        it('should check if JSON contains value', async () => {
+            mockAdapter.executeReadQuery.mockResolvedValue(createMockQueryResult([{ id: 1 }]));
+
+            const tool = createJsonContainsTool(mockAdapter as unknown as MySQLAdapter);
+            await tool.handler({
+                table: 'data',
+                column: 'json_col',
+                value: '"search_term"'
+            }, mockContext);
+
+            const call = mockAdapter.executeReadQuery.mock.calls[0][0] as string;
+            expect(call).toContain('JSON_CONTAINS');
+        });
+
+        it('should include path if provided', async () => {
+            mockAdapter.executeReadQuery.mockResolvedValue(createMockQueryResult([]));
+
+            const tool = createJsonContainsTool(mockAdapter as unknown as MySQLAdapter);
+            await tool.handler({
+                table: 'data',
+                column: 'json_col',
+                value: '"search_term"',
+                path: '$.key'
+            }, mockContext);
+
+            // Expect JSON_CONTAINS(col, val, path)
+            const call = mockAdapter.executeReadQuery.mock.calls[0][0] as string;
+            const args = mockAdapter.executeReadQuery.mock.calls[0][1] as unknown[];
+            expect(call).toContain('JSON_CONTAINS');
+            expect(args).toHaveLength(2); // jsonValue, path
+        });
+    });
+
+    describe('createJsonKeysTool', () => {
+        it('should get JSON keys', async () => {
+            mockAdapter.executeReadQuery.mockResolvedValue(createMockQueryResult([{ json_keys: '["a", "b"]' }]));
+
+            const tool = createJsonKeysTool(mockAdapter as unknown as MySQLAdapter);
+            await tool.handler({
+                table: 'data',
+                column: 'json_col'
+            }, mockContext);
+
+            const call = mockAdapter.executeReadQuery.mock.calls[0][0] as string;
+            expect(call).toContain('JSON_KEYS');
+        });
+    });
+
+    describe('createJsonArrayAppendTool', () => {
+        it('should append to JSON array', async () => {
+            mockAdapter.executeWriteQuery.mockResolvedValue({ rowsAffected: 1, insertId: 0 });
+
+            const tool = createJsonArrayAppendTool(mockAdapter as unknown as MySQLAdapter);
+            await tool.handler({
+                table: 'data',
+                column: 'json_col',
+                path: '$',
+                value: '"item"',
+                where: 'id = 1'
+            }, mockContext);
+
+            const call = mockAdapter.executeWriteQuery.mock.calls[0][0] as string;
+            expect(call).toContain('JSON_ARRAY_APPEND');
+        });
+    });
+});