@neverinfamous/mysql-mcp 2.1.0 → 2.3.0

package/src/adapters/mysql/tools/schema/constraints.ts

@@ -1,41 +1,59 @@
-import { z } from 'zod';
-import type { MySQLAdapter } from '../../MySQLAdapter.js';
-import type { ToolDefinition, RequestContext } from '../../../../types/index.js';
+import { z } from "zod";
+import type { MySQLAdapter } from "../../MySQLAdapter.js";
+import type {
+  ToolDefinition,
+  RequestContext,
+} from "../../../../types/index.js";
 
 const ListConstraintsSchema = z.object({
-    table: z.string().describe('Table name'),
-    type: z.enum(['PRIMARY KEY', 'FOREIGN KEY', 'UNIQUE', 'CHECK']).optional().describe('Filter by constraint type')
+  table: z.string().describe("Table name"),
+  type: z
+    .enum(["PRIMARY KEY", "FOREIGN KEY", "UNIQUE", "CHECK"])
+    .optional()
+    .describe("Filter by constraint type"),
 });
 
 /**
  * List constraints
  */
-export function createListConstraintsTool(adapter: MySQLAdapter): ToolDefinition {
-    return {
-        name: 'mysql_list_constraints',
-        title: 'MySQL List Constraints',
-        description: 'List all constraints (primary key, foreign key, unique, check) for a table.',
-        group: 'schema',
-        inputSchema: ListConstraintsSchema,
-        requiredScopes: ['read'],
-        annotations: {
-            readOnlyHint: true,
-            idempotentHint: true
-        },
-        handler: async (params: unknown, _context: RequestContext) => {
-            const { table, type } = ListConstraintsSchema.parse(params);
+export function createListConstraintsTool(
+  adapter: MySQLAdapter,
+): ToolDefinition {
+  return {
+    name: "mysql_list_constraints",
+    title: "MySQL List Constraints",
+    description:
+      "List all constraints (primary key, foreign key, unique, check) for a table.",
+    group: "schema",
+    inputSchema: ListConstraintsSchema,
+    requiredScopes: ["read"],
+    annotations: {
+      readOnlyHint: true,
+      idempotentHint: true,
+    },
+    handler: async (params: unknown, _context: RequestContext) => {
+      const { table, type } = ListConstraintsSchema.parse(params);
 
-            const parts = table.split('.');
-            let schemaName: string | null = null;
-            let tableName = table;
+      const parts = table.split(".");
+      let schemaName: string | null = null;
+      let tableName = table;
 
-            if (parts.length === 2 && parts[0] && parts[1]) {
-                schemaName = parts[0];
-                tableName = parts[1];
-            }
+      if (parts.length === 2 && parts[0] && parts[1]) {
+        schemaName = parts[0];
+        tableName = parts[1];
+      }
 
-            // Query for table constraints
-            let query = `
+      // P154: Check table existence first
+      const existsResult = await adapter.executeQuery(
+        `SELECT TABLE_NAME FROM information_schema.TABLES WHERE TABLE_SCHEMA = COALESCE(?, DATABASE()) AND TABLE_NAME = ?`,
+        [schemaName, tableName],
+      );
+      if (!existsResult.rows || existsResult.rows.length === 0) {
+        return { exists: false, table: tableName };
+      }
+
+      // Query for table constraints
+      let query = `
                 SELECT 
                     tc.CONSTRAINT_NAME as name,
                     tc.CONSTRAINT_TYPE as type,
@@ -57,21 +75,22 @@ export function createListConstraintsTool(adapter: MySQLAdapter): ToolDefinition
                   AND tc.TABLE_NAME = ?
             `;
 
-            const queryParams: unknown[] = [schemaName, tableName];
+      const queryParams: unknown[] = [schemaName, tableName];
 
-            if (type) {
-                query += ' AND tc.CONSTRAINT_TYPE = ?';
-                queryParams.push(type);
-            }
+      if (type) {
+        query += " AND tc.CONSTRAINT_TYPE = ?";
+        queryParams.push(type);
+      }
 
-            query += ' GROUP BY tc.CONSTRAINT_NAME, tc.CONSTRAINT_TYPE, tc.TABLE_NAME, kcu.REFERENCED_TABLE_NAME, rc.UPDATE_RULE, rc.DELETE_RULE';
-            query += ' ORDER BY tc.CONSTRAINT_TYPE, tc.CONSTRAINT_NAME';
+      query +=
+        " GROUP BY tc.CONSTRAINT_NAME, tc.CONSTRAINT_TYPE, tc.TABLE_NAME, kcu.REFERENCED_TABLE_NAME, rc.UPDATE_RULE, rc.DELETE_RULE";
+      query += " ORDER BY tc.CONSTRAINT_TYPE, tc.CONSTRAINT_NAME";
 
-            const result = await adapter.executeQuery(query, queryParams);
-            return {
-                constraints: result.rows,
-                count: result.rows?.length ?? 0
-            };
-        }
-    };
+      const result = await adapter.executeQuery(query, queryParams);
+      return {
+        constraints: result.rows,
+        count: result.rows?.length ?? 0,
+      };
+    },
+  };
 }

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

@@ -1,54 +1,45 @@
 /**
  * MySQL Schema Management Tools
- * 
+ *
  * Tools for database schema introspection and management.
  */
 
-import type { MySQLAdapter } from '../../MySQLAdapter.js';
-import type { ToolDefinition } from '../../../../types/index.js';
+import type { MySQLAdapter } from "../../MySQLAdapter.js";
+import type { ToolDefinition } from "../../../../types/index.js";
 
 import {
-    createListSchemasTool,
-    createCreateSchemaTool,
-    createDropSchemaTool
-} from './management.js';
+  createListSchemasTool,
+  createCreateSchemaTool,
+  createDropSchemaTool,
+} from "./management.js";
 
-import {
-    createListViewsTool,
-    createCreateViewTool
-} from './views.js';
+import { createListViewsTool, createCreateViewTool } from "./views.js";
 
 import {
-    createListStoredProceduresTool,
-    createListFunctionsTool
-} from './routines.js';
+  createListStoredProceduresTool,
+  createListFunctionsTool,
+} from "./routines.js";
 
-import {
-    createListTriggersTool
-} from './triggers.js';
+import { createListTriggersTool } from "./triggers.js";
 
-import {
-    createListConstraintsTool
-} from './constraints.js';
+import { createListConstraintsTool } from "./constraints.js";
 
-import {
-    createListEventsTool
-} from './scheduled_events.js';
+import { createListEventsTool } from "./scheduled_events.js";
 
 /**
  * Get all schema management tools
  */
 export function getSchemaTools(adapter: MySQLAdapter): ToolDefinition[] {
-    return [
-        createListSchemasTool(adapter),
-        createCreateSchemaTool(adapter),
-        createDropSchemaTool(adapter),
-        createListViewsTool(adapter),
-        createCreateViewTool(adapter),
-        createListStoredProceduresTool(adapter),
-        createListFunctionsTool(adapter),
-        createListTriggersTool(adapter),
-        createListConstraintsTool(adapter),
-        createListEventsTool(adapter)
-    ];
+  return [
+    createListSchemasTool(adapter),
+    createCreateSchemaTool(adapter),
+    createDropSchemaTool(adapter),
+    createListViewsTool(adapter),
+    createCreateViewTool(adapter),
+    createListStoredProceduresTool(adapter),
+    createListFunctionsTool(adapter),
+    createListTriggersTool(adapter),
+    createListConstraintsTool(adapter),
+    createListEventsTool(adapter),
+  ];
 }

package/src/adapters/mysql/tools/schema/management.ts

@@ -1,42 +1,49 @@
-import { z } from 'zod';
-import type { MySQLAdapter } from '../../MySQLAdapter.js';
-import type { ToolDefinition, RequestContext } from '../../../../types/index.js';
+import { z } from "zod";
+import type { MySQLAdapter } from "../../MySQLAdapter.js";
+import type {
+  ToolDefinition,
+  RequestContext,
+} from "../../../../types/index.js";
 
 const ListSchemasSchema = z.object({
-    pattern: z.string().optional().describe('Filter pattern (LIKE syntax, e.g. "app_%")')
+  pattern: z
+    .string()
+    .optional()
+    .describe('Filter pattern (LIKE syntax, e.g. "app_%")'),
 });
 
 const CreateSchemaSchema = z.object({
-    name: z.string().describe('Schema/database name'),
-    charset: z.string().default('utf8mb4').describe('Character set'),
-    collation: z.string().default('utf8mb4_unicode_ci').describe('Collation'),
-    ifNotExists: z.boolean().default(true).describe('Add IF NOT EXISTS clause')
+  name: z.string().describe("Schema/database name"),
+  charset: z.string().default("utf8mb4").describe("Character set"),
+  collation: z.string().default("utf8mb4_unicode_ci").describe("Collation"),
+  ifNotExists: z.boolean().default(true).describe("Add IF NOT EXISTS clause"),
 });
 
 const DropSchemaSchema = z.object({
-    name: z.string().describe('Schema/database name to drop'),
-    ifExists: z.boolean().default(true).describe('Add IF EXISTS clause')
+  name: z.string().describe("Schema/database name to drop"),
+  ifExists: z.boolean().default(true).describe("Add IF EXISTS clause"),
 });
 
 /**
  * List all schemas/databases
  */
 export function createListSchemasTool(adapter: MySQLAdapter): ToolDefinition {
-    return {
-        name: 'mysql_list_schemas',
-        title: 'MySQL List Schemas',
-        description: 'List all databases/schemas with metadata including charset and collation.',
-        group: 'schema',
-        inputSchema: ListSchemasSchema,
-        requiredScopes: ['read'],
-        annotations: {
-            readOnlyHint: true,
-            idempotentHint: true
-        },
-        handler: async (params: unknown, _context: RequestContext) => {
-            const { pattern } = ListSchemasSchema.parse(params);
-
-            let query = `
+  return {
+    name: "mysql_list_schemas",
+    title: "MySQL List Schemas",
+    description:
+      "List all databases/schemas with metadata including charset and collation.",
+    group: "schema",
+    inputSchema: ListSchemasSchema,
+    requiredScopes: ["read"],
+    annotations: {
+      readOnlyHint: true,
+      idempotentHint: true,
+    },
+    handler: async (params: unknown, _context: RequestContext) => {
+      const { pattern } = ListSchemasSchema.parse(params);
+
+      let query = `
                 SELECT 
                     SCHEMA_NAME as name,
                     DEFAULT_CHARACTER_SET_NAME as charset,
@@ -45,87 +52,153 @@ export function createListSchemasTool(adapter: MySQLAdapter): ToolDefinition {
                 WHERE SCHEMA_NAME NOT IN ('information_schema', 'mysql', 'performance_schema', 'sys')
             `;
 
-            const queryParams: unknown[] = [];
-            if (pattern) {
-                query += ' AND SCHEMA_NAME LIKE ?';
-                queryParams.push(pattern);
-            }
-
-            query += ' ORDER BY SCHEMA_NAME';
-
-            const result = await adapter.executeQuery(query, queryParams);
-            return {
-                schemas: result.rows,
-                count: result.rows?.length ?? 0
-            };
-        }
-    };
+      const queryParams: unknown[] = [];
+      if (pattern) {
+        query += " AND SCHEMA_NAME LIKE ?";
+        queryParams.push(pattern);
+      }
+
+      query += " ORDER BY SCHEMA_NAME";
+
+      const result = await adapter.executeQuery(query, queryParams);
+      return {
+        schemas: result.rows,
+        count: result.rows?.length ?? 0,
+      };
+    },
+  };
 }
 
 /**
  * Create a new schema/database
  */
 export function createCreateSchemaTool(adapter: MySQLAdapter): ToolDefinition {
-    return {
-        name: 'mysql_create_schema',
-        title: 'MySQL Create Schema',
-        description: 'Create a new database/schema with specified charset and collation.',
-        group: 'schema',
-        inputSchema: CreateSchemaSchema,
-        requiredScopes: ['admin'],
-        annotations: {
-            readOnlyHint: false
-        },
-        handler: async (params: unknown, _context: RequestContext) => {
-            const { name, charset, collation, ifNotExists } = CreateSchemaSchema.parse(params);
-
-            // Validate schema name
-            if (!/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(name)) {
-                throw new Error('Invalid schema name');
-            }
-
-            const ifNotExistsClause = ifNotExists ? 'IF NOT EXISTS ' : '';
-            const sql = `CREATE DATABASE ${ifNotExistsClause}\`${name}\` CHARACTER SET ${charset} COLLATE ${collation}`;
-
-            await adapter.executeQuery(sql);
-            return { success: true, schemaName: name };
+  return {
+    name: "mysql_create_schema",
+    title: "MySQL Create Schema",
+    description:
+      "Create a new database/schema with specified charset and collation.",
+    group: "schema",
+    inputSchema: CreateSchemaSchema,
+    requiredScopes: ["admin"],
+    annotations: {
+      readOnlyHint: false,
+    },
+    handler: async (params: unknown, _context: RequestContext) => {
+      const { name, charset, collation, ifNotExists } =
+        CreateSchemaSchema.parse(params);
+
+      // Validate schema name
+      if (!/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(name)) {
+        throw new Error("Invalid schema name");
+      }
+
+      // Pre-check: detect no-op when ifNotExists is true
+      if (ifNotExists) {
+        const check = await adapter.executeQuery(
+          "SELECT SCHEMA_NAME FROM information_schema.SCHEMATA WHERE SCHEMA_NAME = ?",
+          [name],
+        );
+        if (check.rows && check.rows.length > 0) {
+          return {
+            success: true,
+            skipped: true,
+            reason: "Schema already exists",
+            schemaName: name,
+          };
         }
-    };
+      }
+
+      const ifNotExistsClause = ifNotExists ? "IF NOT EXISTS " : "";
+      const sql = `CREATE DATABASE ${ifNotExistsClause}\`${name}\` CHARACTER SET ${charset} COLLATE ${collation}`;
+
+      try {
+        await adapter.executeQuery(sql);
+        return { success: true, schemaName: name };
+      } catch (err: unknown) {
+        const message = err instanceof Error ? err.message : String(err);
+        if (message.toLowerCase().includes("database exists")) {
+          return {
+            success: false,
+            reason: `Schema '${name}' already exists`,
+          };
+        }
+        throw err;
+      }
+    },
+  };
 }
 
 /**
  * Drop a schema/database
  */
 export function createDropSchemaTool(adapter: MySQLAdapter): ToolDefinition {
-    return {
-        name: 'mysql_drop_schema',
-        title: 'MySQL Drop Schema',
-        description: 'Drop a database/schema. WARNING: This permanently deletes all data.',
-        group: 'schema',
-        inputSchema: DropSchemaSchema,
-        requiredScopes: ['admin'],
-        annotations: {
-            readOnlyHint: false,
-            destructiveHint: true
-        },
-        handler: async (params: unknown, _context: RequestContext) => {
-            const { name, ifExists } = DropSchemaSchema.parse(params);
-
-            // Validate schema name
-            if (!/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(name)) {
-                throw new Error('Invalid schema name');
-            }
-
-            // Protect system schemas
-            const systemSchemas = ['mysql', 'information_schema', 'performance_schema', 'sys'];
-            if (systemSchemas.includes(name.toLowerCase())) {
-                throw new Error('Cannot drop system schema');
-            }
-
-            const ifExistsClause = ifExists ? 'IF EXISTS ' : '';
-            await adapter.executeQuery(`DROP DATABASE ${ifExistsClause}\`${name}\``);
-
-            return { success: true, schemaName: name };
+  return {
+    name: "mysql_drop_schema",
+    title: "MySQL Drop Schema",
+    description:
+      "Drop a database/schema. WARNING: This permanently deletes all data.",
+    group: "schema",
+    inputSchema: DropSchemaSchema,
+    requiredScopes: ["admin"],
+    annotations: {
+      readOnlyHint: false,
+      destructiveHint: true,
+    },
+    handler: async (params: unknown, _context: RequestContext) => {
+      const { name, ifExists } = DropSchemaSchema.parse(params);
+
+      // Validate schema name
+      if (!/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(name)) {
+        throw new Error("Invalid schema name");
+      }
+
+      // Protect system schemas
+      const systemSchemas = [
+        "mysql",
+        "information_schema",
+        "performance_schema",
+        "sys",
+      ];
+      if (systemSchemas.includes(name.toLowerCase())) {
+        throw new Error("Cannot drop system schema");
+      }
+
+      // Pre-check: detect no-op when ifExists is true
+      if (ifExists) {
+        const check = await adapter.executeQuery(
+          "SELECT SCHEMA_NAME FROM information_schema.SCHEMATA WHERE SCHEMA_NAME = ?",
+          [name],
+        );
+        if (!check.rows || check.rows.length === 0) {
+          return {
+            success: true,
+            skipped: true,
+            reason: "Schema did not exist",
+            schemaName: name,
+          };
+        }
+      }
+
+      const ifExistsClause = ifExists ? "IF EXISTS " : "";
+      try {
+        await adapter.executeQuery(
+          `DROP DATABASE ${ifExistsClause}\`${name}\``,
+        );
+        return { success: true, schemaName: name };
+      } catch (err: unknown) {
+        const message = err instanceof Error ? err.message : String(err);
+        if (
+          message.toLowerCase().includes("database doesn't exist") ||
+          message.toLowerCase().includes("database does not exist")
+        ) {
+          return {
+            success: false,
+            reason: `Schema '${name}' does not exist`,
+          };
         }
-    };
+        throw err;
+      }
+    },
+  };
 }

package/src/adapters/mysql/tools/schema/routines.ts

@@ -1,31 +1,50 @@
-import { z } from 'zod';
-import type { MySQLAdapter } from '../../MySQLAdapter.js';
-import type { ToolDefinition, RequestContext } from '../../../../types/index.js';
+import { z } from "zod";
+import type { MySQLAdapter } from "../../MySQLAdapter.js";
+import type {
+  ToolDefinition,
+  RequestContext,
+} from "../../../../types/index.js";
 
 const ListObjectsSchema = z.object({
-    schema: z.string().optional().describe('Schema name (defaults to current database)'),
-    type: z.enum(['PROCEDURE', 'FUNCTION']).optional().describe('Filter by type')
+  schema: z
+    .string()
+    .optional()
+    .describe("Schema name (defaults to current database)"),
+  type: z.enum(["PROCEDURE", "FUNCTION"]).optional().describe("Filter by type"),
 });
 
 /**
  * List stored procedures
  */
-export function createListStoredProceduresTool(adapter: MySQLAdapter): ToolDefinition {
-    return {
-        name: 'mysql_list_stored_procedures',
-        title: 'MySQL List Stored Procedures',
-        description: 'List all stored procedures with parameters and metadata.',
-        group: 'schema',
-        inputSchema: ListObjectsSchema,
-        requiredScopes: ['read'],
-        annotations: {
-            readOnlyHint: true,
-            idempotentHint: true
-        },
-        handler: async (params: unknown, _context: RequestContext) => {
-            const { schema } = ListObjectsSchema.parse(params);
+export function createListStoredProceduresTool(
+  adapter: MySQLAdapter,
+): ToolDefinition {
+  return {
+    name: "mysql_list_stored_procedures",
+    title: "MySQL List Stored Procedures",
+    description: "List all stored procedures with parameters and metadata.",
+    group: "schema",
+    inputSchema: ListObjectsSchema,
+    requiredScopes: ["read"],
+    annotations: {
+      readOnlyHint: true,
+      idempotentHint: true,
+    },
+    handler: async (params: unknown, _context: RequestContext) => {
+      const { schema } = ListObjectsSchema.parse(params);
 
-            const query = `
+      // 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 = `
                 SELECT 
                     r.ROUTINE_NAME as name,
                     r.ROUTINE_TYPE as type,
@@ -52,34 +71,46 @@ export function createListStoredProceduresTool(adapter: MySQLAdapter): ToolDefin
                 ORDER BY r.ROUTINE_NAME
             `;
 
-            const result = await adapter.executeQuery(query, [schema ?? null]);
-            return {
-                procedures: result.rows,
-                count: result.rows?.length ?? 0
-            };
-        }
-    };
+      const result = await adapter.executeQuery(query, [schema ?? null]);
+      return {
+        procedures: result.rows,
+        count: result.rows?.length ?? 0,
+      };
+    },
+  };
 }
 
 /**
  * List user-defined functions
  */
 export function createListFunctionsTool(adapter: MySQLAdapter): ToolDefinition {
-    return {
-        name: 'mysql_list_functions',
-        title: 'MySQL List Functions',
-        description: 'List all user-defined functions with return types and metadata.',
-        group: 'schema',
-        inputSchema: ListObjectsSchema,
-        requiredScopes: ['read'],
-        annotations: {
-            readOnlyHint: true,
-            idempotentHint: true
-        },
-        handler: async (params: unknown, _context: RequestContext) => {
-            const { schema } = ListObjectsSchema.parse(params);
+  return {
+    name: "mysql_list_functions",
+    title: "MySQL List Functions",
+    description:
+      "List all user-defined functions with return types and metadata.",
+    group: "schema",
+    inputSchema: ListObjectsSchema,
+    requiredScopes: ["read"],
+    annotations: {
+      readOnlyHint: true,
+      idempotentHint: true,
+    },
+    handler: async (params: unknown, _context: RequestContext) => {
+      const { schema } = ListObjectsSchema.parse(params);
 
-            const query = `
+      // 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 = `
                 SELECT 
                     r.ROUTINE_NAME as name,
                     r.DATA_TYPE as returnType,
@@ -96,11 +127,11 @@ export function createListFunctionsTool(adapter: MySQLAdapter): ToolDefinition {
                 ORDER BY r.ROUTINE_NAME
             `;
 
-            const result = await adapter.executeQuery(query, [schema ?? null]);
-            return {
-                functions: result.rows,
-                count: result.rows?.length ?? 0
-            };
-        }
-    };
+      const result = await adapter.executeQuery(query, [schema ?? null]);
+      return {
+        functions: result.rows,
+        count: result.rows?.length ?? 0,
+      };
+    },
+  };
 }