@neverinfamous/mysql-mcp 2.3.0 → 3.0.0

package/dist/adapters/mysql/tools/events.js

@@ -4,7 +4,11 @@
  * Tools for managing MySQL's built-in Event Scheduler.
  * 6 tools total.
  */
-import { z } from "zod";
+import { z, ZodError } from "zod";
+/** Extract human-readable messages from a ZodError instead of raw JSON array */
+function formatZodError(error) {
+    return error.issues.map((i) => i.message).join("; ");
+}
 // =============================================================================
 // Zod Schemas
 // =============================================================================
@@ -12,23 +16,14 @@ const EventCreateSchema = z.object({
     name: z.string().describe("Event name"),
     schedule: z
         .object({
-        type: z.enum(["ONE TIME", "RECURRING"]).describe("Event schedule type"),
+        type: z.string().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",
-        ])
+            .string()
             .optional()
             .describe("For RECURRING: interval unit"),
         starts: z.string().optional().describe("For RECURRING: start timestamp"),
@@ -37,7 +32,7 @@ const EventCreateSchema = z.object({
         .describe("Event schedule configuration"),
     body: z.string().describe("SQL statement(s) to execute"),
     onCompletion: z
-        .enum(["PRESERVE", "NOT PRESERVE"])
+        .string()
         .default("NOT PRESERVE")
         .describe("What to do after event completes"),
     enabled: z.boolean().default(true).describe("Whether event is enabled"),
@@ -49,28 +44,17 @@ const EventAlterSchema = z.object({
     newName: z.string().optional().describe("New event name (for rename)"),
     schedule: z
         .object({
-        type: z.enum(["ONE TIME", "RECURRING"]).optional(),
+        type: z.string().optional(),
         executeAt: z.string().optional(),
         interval: z.number().optional(),
-        intervalUnit: z
-            .enum([
-            "YEAR",
-            "QUARTER",
-            "MONTH",
-            "DAY",
-            "HOUR",
-            "MINUTE",
-            "WEEK",
-            "SECOND",
-        ])
-            .optional(),
+        intervalUnit: z.string().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(),
+    onCompletion: z.string().optional(),
     enabled: z.boolean().optional().describe("Enable or disable event"),
     comment: z.string().optional(),
 });
@@ -123,71 +107,106 @@ function createEventCreateTool(adapter) {
             readOnlyHint: false,
         },
         handler: async (params, _context) => {
-            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");
-            }
-            // Pre-check event existence for informative messaging
-            if (ifNotExists) {
-                const existsCheck = await adapter.executeQuery("SELECT EVENT_NAME FROM information_schema.EVENTS WHERE EVENT_SCHEMA = DATABASE() AND EVENT_NAME = ?", [name]);
-                if (existsCheck.rows && existsCheck.rows.length > 0) {
+            try {
+                const { name, schedule, body, onCompletion, enabled, comment, ifNotExists, } = EventCreateSchema.parse(params);
+                if (!/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(name)) {
+                    return { success: false, error: "Invalid event name" };
+                }
+                // Validate enum fields at handler level
+                const validScheduleTypes = ["ONE TIME", "RECURRING"];
+                if (!validScheduleTypes.includes(schedule.type)) {
                     return {
-                        success: true,
-                        skipped: true,
-                        reason: "Event already exists",
-                        eventName: name,
+                        success: false,
+                        error: `Invalid schedule type: '${schedule.type}' — expected one of: ${validScheduleTypes.join(", ")}`,
                     };
                 }
-            }
-            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");
+                const validOnCompletion = ["PRESERVE", "NOT PRESERVE"];
+                if (!validOnCompletion.includes(onCompletion)) {
+                    return {
+                        success: false,
+                        error: `Invalid onCompletion: '${onCompletion}' — expected one of: ${validOnCompletion.join(", ")}`,
+                    };
                 }
-                sql += `EVERY ${String(schedule.interval)} ${schedule.intervalUnit}`;
-                if (schedule.starts) {
-                    sql += ` STARTS '${schedule.starts}'`;
+                if (ifNotExists) {
+                    const existsCheck = await adapter.executeQuery("SELECT EVENT_NAME FROM information_schema.EVENTS WHERE EVENT_SCHEMA = DATABASE() AND EVENT_NAME = ?", [name]);
+                    if (existsCheck.rows && existsCheck.rows.length > 0) {
+                        return {
+                            success: true,
+                            skipped: true,
+                            reason: "Event already exists",
+                            eventName: name,
+                        };
+                    }
                 }
-                if (schedule.ends) {
-                    sql += ` ENDS '${schedule.ends}'`;
+                const ifNotExistsClause = ifNotExists ? "IF NOT EXISTS " : "";
+                let sql = `CREATE EVENT ${ifNotExistsClause}\`${name}\`\nON SCHEDULE `;
+                if (schedule.type === "ONE TIME") {
+                    if (!schedule.executeAt) {
+                        return {
+                            success: false,
+                            error: "executeAt is required for ONE TIME events",
+                        };
+                    }
+                    sql += `AT '${schedule.executeAt}'`;
                 }
-            }
-            sql += `\nON COMPLETION ${onCompletion}`;
-            if (!enabled) {
-                sql += "\nDISABLE";
-            }
-            else {
-                sql += "\nENABLE";
-            }
-            if (comment) {
-                sql += `\nCOMMENT '${comment.replace(/'/g, "''")}'`;
-            }
-            sql += `\nDO ${body}`;
-            try {
+                else {
+                    if (schedule.interval === undefined ||
+                        schedule.interval === null ||
+                        schedule.intervalUnit === undefined ||
+                        schedule.intervalUnit === null) {
+                        return {
+                            success: false,
+                            error: "interval and intervalUnit are required for RECURRING events",
+                        };
+                    }
+                    const validUnits = [
+                        "YEAR",
+                        "QUARTER",
+                        "MONTH",
+                        "DAY",
+                        "HOUR",
+                        "MINUTE",
+                        "WEEK",
+                        "SECOND",
+                    ];
+                    if (!validUnits.includes(schedule.intervalUnit)) {
+                        return {
+                            success: false,
+                            error: `Invalid intervalUnit: '${schedule.intervalUnit}' — expected one of: ${validUnits.join(", ")}`,
+                        };
+                    }
+                    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 };
             }
             catch (error) {
+                if (error instanceof ZodError) {
+                    return { success: false, error: formatZodError(error) };
+                }
                 const message = error instanceof Error ? error.message : String(error);
                 if (message.toLowerCase().includes("already exists")) {
-                    return {
-                        success: false,
-                        reason: `Event '${name}' already exists`,
-                    };
+                    return { success: false, error: "Event already exists" };
                 }
-                throw error;
+                const cleaned = message.replace(/^(Query failed: )?(Execute failed: )?/i, "");
+                return { success: false, error: cleaned };
             }
         },
     };
@@ -207,74 +226,113 @@ function createEventAlterTool(adapter) {
             readOnlyHint: false,
         },
         handler: async (params, _context) => {
-            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 = [];
-            // 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");
+            try {
+                const { name, newName, schedule, body, onCompletion, enabled, comment, } = EventAlterSchema.parse(params);
+                if (!/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(name)) {
+                    return { success: false, error: "Invalid event name" };
+                }
+                // Validate enum fields at handler level
+                if (onCompletion !== undefined) {
+                    const validOnCompletion = ["PRESERVE", "NOT PRESERVE"];
+                    if (!validOnCompletion.includes(onCompletion)) {
+                        return {
+                            success: false,
+                            error: `Invalid onCompletion: '${onCompletion}' — expected one of: ${validOnCompletion.join(", ")}`,
+                        };
                     }
-                    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");
+                let sql = `ALTER EVENT \`${name}\``;
+                const clauses = [];
+                if (schedule?.type) {
+                    // Validate schedule.type
+                    const validScheduleTypes = ["ONE TIME", "RECURRING"];
+                    if (!validScheduleTypes.includes(schedule.type)) {
+                        return {
+                            success: false,
+                            error: `Invalid schedule type: '${schedule.type}' — expected one of: ${validScheduleTypes.join(", ")}`,
+                        };
                     }
-                    scheduleClause += `EVERY ${String(schedule.interval)} ${schedule.intervalUnit}`;
-                    if (schedule.starts) {
-                        scheduleClause += ` STARTS '${schedule.starts}'`;
+                    let scheduleClause = "ON SCHEDULE ";
+                    if (schedule.type === "ONE TIME") {
+                        if (!schedule.executeAt) {
+                            return {
+                                success: false,
+                                error: "executeAt is required for ONE TIME events",
+                            };
+                        }
+                        scheduleClause += `AT '${schedule.executeAt}'`;
                     }
-                    if (schedule.ends) {
-                        scheduleClause += ` ENDS '${schedule.ends}'`;
+                    else {
+                        if (schedule.interval === undefined ||
+                            schedule.interval === null ||
+                            schedule.intervalUnit === undefined ||
+                            schedule.intervalUnit === null) {
+                            return {
+                                success: false,
+                                error: "interval and intervalUnit are required for RECURRING events",
+                            };
+                        }
+                        const validUnits = [
+                            "YEAR",
+                            "QUARTER",
+                            "MONTH",
+                            "DAY",
+                            "HOUR",
+                            "MINUTE",
+                            "WEEK",
+                            "SECOND",
+                        ];
+                        if (!validUnits.includes(schedule.intervalUnit)) {
+                            return {
+                                success: false,
+                                error: `Invalid intervalUnit: '${schedule.intervalUnit}' — expected one of: ${validUnits.join(", ")}`,
+                            };
+                        }
+                        scheduleClause += `EVERY ${String(schedule.interval)} ${schedule.intervalUnit}`;
+                        if (schedule.starts) {
+                            scheduleClause += ` STARTS '${schedule.starts}'`;
+                        }
+                        if (schedule.ends) {
+                            scheduleClause += ` ENDS '${schedule.ends}'`;
+                        }
                     }
+                    clauses.push(scheduleClause);
                 }
-                clauses.push(scheduleClause);
-            }
-            if (onCompletion) {
-                clauses.push(`ON COMPLETION ${onCompletion}`);
-            }
-            if (newName) {
-                if (!/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(newName)) {
-                    throw new Error("Invalid new event name");
+                if (onCompletion) {
+                    clauses.push(`ON COMPLETION ${onCompletion}`);
                 }
-                clauses.push(`RENAME TO \`${newName}\``);
-            }
-            if (enabled !== undefined) {
-                clauses.push(enabled ? "ENABLE" : "DISABLE");
-            }
-            if (comment !== undefined) {
-                clauses.push(`COMMENT '${comment.replace(/'/g, "''")}'`);
-            }
-            if (body) {
-                clauses.push(`DO ${body}`);
-            }
-            if (clauses.length === 0) {
-                throw new Error("No modifications specified");
-            }
-            sql += "\n" + clauses.join("\n");
-            try {
+                if (newName) {
+                    if (!/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(newName)) {
+                        return { success: false, error: "Invalid new event name" };
+                    }
+                    clauses.push(`RENAME TO \`${newName}\``);
+                }
+                if (enabled !== undefined) {
+                    clauses.push(enabled ? "ENABLE" : "DISABLE");
+                }
+                if (comment !== undefined) {
+                    clauses.push(`COMMENT '${comment.replace(/'/g, "''")}'`);
+                }
+                if (body) {
+                    clauses.push(`DO ${body}`);
+                }
+                if (clauses.length === 0) {
+                    return { success: false, error: "No modifications specified" };
+                }
+                sql += "\n" + clauses.join("\n");
                 await adapter.executeQuery(sql);
                 return { success: true, eventName: newName ?? name };
             }
             catch (error) {
+                if (error instanceof ZodError) {
+                    return { success: false, error: formatZodError(error) };
+                }
                 const message = error instanceof Error ? error.message : String(error);
                 if (message.toLowerCase().includes("unknown event")) {
-                    return {
-                        success: false,
-                        reason: `Event '${name}' does not exist`,
-                    };
+                    return { success: false, error: "Event does not exist" };
                 }
-                throw error;
+                const cleaned = message.replace(/^(Query failed: )?(Execute failed: )?/i, "");
+                return { success: false, error: cleaned };
             }
         },
     };
@@ -295,37 +353,35 @@ function createEventDropTool(adapter) {
             destructiveHint: true,
         },
         handler: async (params, _context) => {
-            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");
-            }
-            // Pre-check event existence for informative messaging
-            if (ifExists) {
-                const existsCheck = await adapter.executeQuery("SELECT EVENT_NAME FROM information_schema.EVENTS WHERE EVENT_SCHEMA = DATABASE() AND EVENT_NAME = ?", [name]);
-                if (!existsCheck.rows || existsCheck.rows.length === 0) {
-                    return {
-                        success: true,
-                        skipped: true,
-                        reason: "Event did not exist",
-                        eventName: name,
-                    };
-                }
-            }
-            const ifExistsClause = ifExists ? "IF EXISTS " : "";
             try {
+                const { name, ifExists } = EventDropSchema.parse(params);
+                if (!/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(name)) {
+                    return { success: false, error: "Invalid event name" };
+                }
+                if (ifExists) {
+                    const existsCheck = await adapter.executeQuery("SELECT EVENT_NAME FROM information_schema.EVENTS WHERE EVENT_SCHEMA = DATABASE() AND EVENT_NAME = ?", [name]);
+                    if (!existsCheck.rows || existsCheck.rows.length === 0) {
+                        return {
+                            success: true,
+                            skipped: true,
+                            reason: "Event did not exist",
+                            eventName: name,
+                        };
+                    }
+                }
+                const ifExistsClause = ifExists ? "IF EXISTS " : "";
                 await adapter.executeQuery(`DROP EVENT ${ifExistsClause}\`${name}\``);
                 return { success: true, eventName: name };
             }
             catch (error) {
+                if (error instanceof ZodError) {
+                    return { success: false, error: formatZodError(error) };
+                }
                 const message = error instanceof Error ? error.message : String(error);
                 if (message.toLowerCase().includes("unknown event")) {
-                    return {
-                        success: false,
-                        reason: `Event '${name}' does not exist`,
-                    };
+                    return { success: false, error: "Event does not exist" };
                 }
-                throw error;
+                return { success: false, error: message };
             }
         },
     };
@@ -346,15 +402,16 @@ function createEventListTool(adapter) {
             idempotentHint: true,
         },
         handler: async (params, _context) => {
-            const { schema, includeDisabled } = EventListSchema.parse(params);
-            // P154: Schema existence check when explicitly provided
-            if (schema) {
-                const schemaCheck = await adapter.executeQuery("SELECT SCHEMA_NAME FROM information_schema.SCHEMATA WHERE SCHEMA_NAME = ?", [schema]);
-                if (!schemaCheck.rows || schemaCheck.rows.length === 0) {
-                    return { exists: false, schema };
+            try {
+                const { schema, includeDisabled } = EventListSchema.parse(params);
+                // P154: Schema existence check when explicitly provided
+                if (schema) {
+                    const schemaCheck = await adapter.executeQuery("SELECT SCHEMA_NAME FROM information_schema.SCHEMATA WHERE SCHEMA_NAME = ?", [schema]);
+                    if (!schemaCheck.rows || schemaCheck.rows.length === 0) {
+                        return { exists: false, schema };
+                    }
                 }
-            }
-            let query = `
+                let query = `
                 SELECT 
                     EVENT_NAME as name,
                     EVENT_SCHEMA as schemaName,
@@ -372,16 +429,24 @@ function createEventListTool(adapter) {
                 FROM information_schema.EVENTS
                 WHERE EVENT_SCHEMA = COALESCE(?, DATABASE())
             `;
-            const queryParams = [schema ?? null];
-            if (!includeDisabled) {
-                query += " AND STATUS = 'ENABLED'";
+                const queryParams = [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,
+                };
+            }
+            catch (error) {
+                if (error instanceof ZodError) {
+                    return { success: false, error: formatZodError(error) };
+                }
+                const message = error instanceof Error ? error.message : String(error);
+                return { success: false, error: message };
             }
-            query += " ORDER BY EVENT_NAME";
-            const result = await adapter.executeQuery(query, queryParams);
-            return {
-                events: result.rows,
-                count: result.rows?.length ?? 0,
-            };
         },
     };
 }
@@ -401,15 +466,16 @@ function createEventStatusTool(adapter) {
             idempotentHint: true,
         },
         handler: async (params, _context) => {
-            const { name, schema } = EventStatusSchema.parse(params);
-            // P154: Schema existence check when explicitly provided
-            if (schema) {
-                const schemaCheck = await adapter.executeQuery("SELECT SCHEMA_NAME FROM information_schema.SCHEMATA WHERE SCHEMA_NAME = ?", [schema]);
-                if (!schemaCheck.rows || schemaCheck.rows.length === 0) {
-                    return { exists: false, schema };
+            try {
+                const { name, schema } = EventStatusSchema.parse(params);
+                // P154: Schema existence check when explicitly provided
+                if (schema) {
+                    const schemaCheck = await adapter.executeQuery("SELECT SCHEMA_NAME FROM information_schema.SCHEMATA WHERE SCHEMA_NAME = ?", [schema]);
+                    if (!schemaCheck.rows || schemaCheck.rows.length === 0) {
+                        return { exists: false, schema };
+                    }
                 }
-            }
-            const query = `
+                const query = `
                 SELECT 
                     EVENT_NAME as name,
                     EVENT_SCHEMA as schemaName,
@@ -432,11 +498,22 @@ function createEventStatusTool(adapter) {
                 WHERE EVENT_SCHEMA = COALESCE(?, DATABASE())
                   AND EVENT_NAME = ?
             `;
-            const result = await adapter.executeQuery(query, [schema ?? null, name]);
-            if (!result.rows || result.rows.length === 0) {
-                return { exists: false, name };
+                const result = await adapter.executeQuery(query, [
+                    schema ?? null,
+                    name,
+                ]);
+                if (!result.rows || result.rows.length === 0) {
+                    return { exists: false, name };
+                }
+                return result.rows[0];
+            }
+            catch (error) {
+                if (error instanceof ZodError) {
+                    return { success: false, error: formatZodError(error) };
+                }
+                const message = error instanceof Error ? error.message : String(error);
+                return { success: false, error: message };
             }
-            return result.rows[0];
         },
     };
 }
@@ -456,18 +533,19 @@ function createSchedulerStatusTool(adapter) {
             idempotentHint: true,
         },
         handler: async (_params, _context) => {
-            // Get scheduler status
-            const statusResult = await adapter.executeQuery("SHOW VARIABLES LIKE 'event_scheduler'");
-            // Get event counts by status
-            const countResult = await adapter.executeQuery(`
+            try {
+                // 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(`
+                // Get recently executed events
+                const recentResult = await adapter.executeQuery(`
                 SELECT 
                     EVENT_NAME as name,
                     EVENT_SCHEMA as schemaName,
@@ -477,13 +555,21 @@ function createSchedulerStatusTool(adapter) {
                 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 ?? [],
-            };
+                const schedulerStatus = statusResult.rows?.[0];
+                return {
+                    schedulerEnabled: schedulerStatus?.["Value"] === "ON",
+                    schedulerStatus: schedulerStatus?.["Value"] ?? "UNKNOWN",
+                    eventCounts: countResult.rows ?? [],
+                    recentlyExecuted: recentResult.rows ?? [],
+                };
+            }
+            catch (error) {
+                if (error instanceof ZodError) {
+                    return { success: false, error: formatZodError(error) };
+                }
+                const message = error instanceof Error ? error.message : String(error);
+                return { success: false, error: message };
+            }
         },
     };
 }