@neverinfamous/mysql-mcp 2.3.1 → 3.0.1

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

@@ -5,10 +5,15 @@
  * 6 tools total.
  */
 
-import { z } from "zod";
+import { z, ZodError } from "zod";
 import type { MySQLAdapter } from "../MySQLAdapter.js";
 import type { ToolDefinition, RequestContext } from "../../../types/index.js";
 
+/** Extract human-readable messages from a ZodError instead of raw JSON array */
+function formatZodError(error: ZodError): string {
+  return error.issues.map((i) => i.message).join("; ");
+}
+
 // =============================================================================
 // Zod Schemas
 // =============================================================================
@@ -17,7 +22,7 @@ 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()
@@ -26,16 +31,7 @@ const EventCreateSchema = z.object({
         ),
       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"),
@@ -44,7 +40,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"),
@@ -57,28 +53,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(),
 });
@@ -137,92 +122,132 @@ function createEventCreateTool(adapter: MySQLAdapter): ToolDefinition {
       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");
-      }
+      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" };
+        }
 
-      // 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) {
+        // 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");
+        const validOnCompletion = ["PRESERVE", "NOT PRESERVE"];
+        if (!validOnCompletion.includes(onCompletion)) {
+          return {
+            success: false,
+            error: `Invalid onCompletion: '${onCompletion}' — expected one of: ${validOnCompletion.join(", ")}`,
+          };
         }
-        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",
+
+        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,
+            };
+          }
         }
-        sql += `EVERY ${String(schedule.interval)} ${schedule.intervalUnit}`;
-        if (schedule.starts) {
-          sql += ` STARTS '${schedule.starts}'`;
-        }
-        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}'`;
+        } 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}`;
+        sql += `\nON COMPLETION ${onCompletion}`;
 
-      if (!enabled) {
-        sql += "\nDISABLE";
-      } else {
-        sql += "\nENABLE";
-      }
+        if (!enabled) {
+          sql += "\nDISABLE";
+        } else {
+          sql += "\nENABLE";
+        }
 
-      if (comment) {
-        sql += `\nCOMMENT '${comment.replace(/'/g, "''")}'`;
-      }
+        if (comment) {
+          sql += `\nCOMMENT '${comment.replace(/'/g, "''")}'`;
+        }
 
-      sql += `\nDO ${body}`;
+        sql += `\nDO ${body}`;
 
-      try {
         await adapter.executeQuery(sql);
         return { success: true, eventName: name };
       } catch (error: unknown) {
+        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 };
       }
     },
   };
@@ -244,88 +269,139 @@ function createEventAlterTool(adapter: MySQLAdapter): ToolDefinition {
       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[] = [];
+      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" };
+        }
 
-      // 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",
-            );
+        // 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 += `EVERY ${String(schedule.interval)} ${schedule.intervalUnit}`;
-          if (schedule.starts) {
-            scheduleClause += ` STARTS '${schedule.starts}'`;
+        }
+
+        let sql = `ALTER EVENT \`${name}\``;
+        const clauses: string[] = [];
+
+        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(", ")}`,
+            };
           }
-          if (schedule.ends) {
-            scheduleClause += ` ENDS '${schedule.ends}'`;
+
+          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}'`;
+          } 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 (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 (newName) {
+          if (!/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(newName)) {
+            return { success: false, error: "Invalid new event name" };
+          }
+          clauses.push(`RENAME TO \`${newName}\``);
         }
-        clauses.push(`RENAME TO \`${newName}\``);
-      }
 
-      if (enabled !== undefined) {
-        clauses.push(enabled ? "ENABLE" : "DISABLE");
-      }
+        if (enabled !== undefined) {
+          clauses.push(enabled ? "ENABLE" : "DISABLE");
+        }
 
-      if (comment !== undefined) {
-        clauses.push(`COMMENT '${comment.replace(/'/g, "''")}'`);
-      }
+        if (comment !== undefined) {
+          clauses.push(`COMMENT '${comment.replace(/'/g, "''")}'`);
+        }
 
-      if (body) {
-        clauses.push(`DO ${body}`);
-      }
+        if (body) {
+          clauses.push(`DO ${body}`);
+        }
 
-      if (clauses.length === 0) {
-        throw new Error("No modifications specified");
-      }
+        if (clauses.length === 0) {
+          return { success: false, error: "No modifications specified" };
+        }
 
-      sql += "\n" + clauses.join("\n");
+        sql += "\n" + clauses.join("\n");
 
-      try {
         await adapter.executeQuery(sql);
         return { success: true, eventName: newName ?? name };
       } catch (error: unknown) {
+        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 };
       }
     },
   };
@@ -347,43 +423,41 @@ function createEventDropTool(adapter: MySQLAdapter): ToolDefinition {
       destructiveHint: true,
     },
     handler: async (params: unknown, _context: RequestContext) => {
-      const { name, ifExists } = EventDropSchema.parse(params);
+      try {
+        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");
-      }
+        if (!/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(name)) {
+          return { success: false, 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,
-          };
+        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 " : "";
+        const ifExistsClause = ifExists ? "IF EXISTS " : "";
 
-      try {
         await adapter.executeQuery(`DROP EVENT ${ifExistsClause}\`${name}\``);
         return { success: true, eventName: name };
       } catch (error: unknown) {
+        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 };
       }
     },
   };
@@ -406,20 +480,21 @@ function createEventListTool(adapter: MySQLAdapter): ToolDefinition {
       idempotentHint: true,
     },
     handler: async (params: unknown, _context: RequestContext) => {
-      const { schema, includeDisabled } = EventListSchema.parse(params);
+      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 };
+        // 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,
@@ -438,19 +513,26 @@ function createEventListTool(adapter: MySQLAdapter): ToolDefinition {
                 WHERE EVENT_SCHEMA = COALESCE(?, DATABASE())
             `;
 
-      const queryParams: unknown[] = [schema ?? null];
+        const queryParams: unknown[] = [schema ?? null];
 
-      if (!includeDisabled) {
-        query += " AND STATUS = 'ENABLED'";
-      }
+        if (!includeDisabled) {
+          query += " AND STATUS = 'ENABLED'";
+        }
 
-      query += " ORDER BY EVENT_NAME";
+        query += " ORDER BY EVENT_NAME";
 
-      const result = await adapter.executeQuery(query, queryParams);
-      return {
-        events: result.rows,
-        count: result.rows?.length ?? 0,
-      };
+        const result = await adapter.executeQuery(query, queryParams);
+        return {
+          events: result.rows,
+          count: result.rows?.length ?? 0,
+        };
+      } catch (error: unknown) {
+        if (error instanceof ZodError) {
+          return { success: false, error: formatZodError(error) };
+        }
+        const message = error instanceof Error ? error.message : String(error);
+        return { success: false, error: message };
+      }
     },
   };
 }
@@ -472,20 +554,21 @@ function createEventStatusTool(adapter: MySQLAdapter): ToolDefinition {
       idempotentHint: true,
     },
     handler: async (params: unknown, _context: RequestContext) => {
-      const { name, schema } = EventStatusSchema.parse(params);
+      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 };
+        // 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,
@@ -509,13 +592,23 @@ function createEventStatusTool(adapter: MySQLAdapter): ToolDefinition {
                   AND EVENT_NAME = ?
             `;
 
-      const result = await adapter.executeQuery(query, [schema ?? null, name]);
+        const result = await adapter.executeQuery(query, [
+          schema ?? null,
+          name,
+        ]);
 
-      if (!result.rows || result.rows.length === 0) {
-        return { exists: false, name };
-      }
+        if (!result.rows || result.rows.length === 0) {
+          return { exists: false, name };
+        }
 
-      return result.rows[0];
+        return result.rows[0];
+      } catch (error: unknown) {
+        if (error instanceof ZodError) {
+          return { success: false, error: formatZodError(error) };
+        }
+        const message = error instanceof Error ? error.message : String(error);
+        return { success: false, error: message };
+      }
     },
   };
 }
@@ -536,13 +629,14 @@ function createSchedulerStatusTool(adapter: MySQLAdapter): ToolDefinition {
       idempotentHint: true,
     },
     handler: async (_params: unknown, _context: RequestContext) => {
-      // Get scheduler status
-      const statusResult = await adapter.executeQuery(
-        "SHOW VARIABLES LIKE 'event_scheduler'",
-      );
+      try {
+        // Get scheduler status
+        const statusResult = await adapter.executeQuery(
+          "SHOW VARIABLES LIKE 'event_scheduler'",
+        );
 
-      // Get event counts by status
-      const countResult = await adapter.executeQuery(`
+        // Get event counts by status
+        const countResult = await adapter.executeQuery(`
                 SELECT 
                     STATUS as status,
                     COUNT(*) as count
@@ -550,8 +644,8 @@ function createSchedulerStatusTool(adapter: MySQLAdapter): ToolDefinition {
                 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,
@@ -562,14 +656,21 @@ function createSchedulerStatusTool(adapter: MySQLAdapter): ToolDefinition {
                 LIMIT 10
             `);
 
-      const schedulerStatus = statusResult.rows?.[0];
+        const schedulerStatus = statusResult.rows?.[0];
 
-      return {
-        schedulerEnabled: schedulerStatus?.["Value"] === "ON",
-        schedulerStatus: schedulerStatus?.["Value"] ?? "UNKNOWN",
-        eventCounts: countResult.rows ?? [],
-        recentlyExecuted: recentResult.rows ?? [],
-      };
+        return {
+          schedulerEnabled: schedulerStatus?.["Value"] === "ON",
+          schedulerStatus: schedulerStatus?.["Value"] ?? "UNKNOWN",
+          eventCounts: countResult.rows ?? [],
+          recentlyExecuted: recentResult.rows ?? [],
+        };
+      } catch (error: unknown) {
+        if (error instanceof ZodError) {
+          return { success: false, error: formatZodError(error) };
+        }
+        const message = error instanceof Error ? error.message : String(error);
+        return { success: false, error: message };
+      }
     },
   };
 }