@neverinfamous/mysql-mcp 2.3.0 → 3.0.0

package/src/adapters/mysql/resources/innodb.ts

@@ -23,10 +23,30 @@ export function createInnodbResource(
       priority: 0.7,
     },
     handler: async (_uri: string, _context: RequestContext) => {
-      // Get buffer pool status
-      const bufferPoolResult = await adapter.executeQuery(`
+      // Performance optimization: run all three independent queries in parallel
+      const [bufferPoolResult, configResult, opsResult] = await Promise.all([
+        // Get buffer pool status
+        adapter.executeQuery(`
                 SHOW GLOBAL STATUS WHERE Variable_name LIKE 'Innodb_buffer_pool%'
-            `);
+            `),
+        // Get buffer pool size configuration
+        adapter.executeQuery(`
+                SHOW GLOBAL VARIABLES WHERE Variable_name IN (
+                    'innodb_buffer_pool_size', 'innodb_buffer_pool_instances',
+                    'innodb_log_file_size', 'innodb_log_files_in_group',
+                    'innodb_flush_log_at_trx_commit', 'innodb_file_per_table'
+                )
+            `),
+        // Get row operations
+        adapter.executeQuery(`
+                SHOW GLOBAL STATUS WHERE Variable_name IN (
+                    'Innodb_rows_read', 'Innodb_rows_inserted', 
+                    'Innodb_rows_updated', 'Innodb_rows_deleted',
+                    'Innodb_data_reads', 'Innodb_data_writes',
+                    'Innodb_os_log_written', 'Innodb_log_writes'
+                )
+            `),
+      ]);
 
       const bufferPool: Record<string, number> = {};
       for (const row of bufferPoolResult.rows ?? []) {
@@ -36,30 +56,11 @@ export function createInnodbResource(
         );
       }
 
-      // Get buffer pool size configuration
-      const configResult = await adapter.executeQuery(`
-                SHOW GLOBAL VARIABLES WHERE Variable_name IN (
-                    'innodb_buffer_pool_size', 'innodb_buffer_pool_instances',
-                    'innodb_log_file_size', 'innodb_log_files_in_group',
-                    'innodb_flush_log_at_trx_commit', 'innodb_file_per_table'
-                )
-            `);
-
       const config: Record<string, string> = {};
       for (const row of configResult.rows ?? []) {
         config[row["Variable_name"] as string] = row["Value"] as string;
       }
 
-      // Get row operations
-      const opsResult = await adapter.executeQuery(`
-                SHOW GLOBAL STATUS WHERE Variable_name IN (
-                    'Innodb_rows_read', 'Innodb_rows_inserted', 
-                    'Innodb_rows_updated', 'Innodb_rows_deleted',
-                    'Innodb_data_reads', 'Innodb_data_writes',
-                    'Innodb_os_log_written', 'Innodb_log_writes'
-                )
-            `);
-
       const operations: Record<string, number> = {};
       for (const row of opsResult.rows ?? []) {
         operations[row["Variable_name"] as string] = parseInt(

package/src/adapters/mysql/resources/locks.ts

@@ -20,8 +20,10 @@ export function createLocksResource(adapter: MySQLAdapter): ResourceDefinition {
     },
     handler: async (_uri: string, _context: RequestContext) => {
       try {
-        // Get current lock waits from performance_schema
-        const lockWaitsResult = await adapter.executeQuery(`
+        // Performance optimization: run both independent queries in parallel
+        const [lockWaitsResult, lockStatusResult] = await Promise.all([
+          // Get current lock waits from performance_schema
+          adapter.executeQuery(`
                     SELECT 
                         r.trx_id AS waiting_trx_id,
                         r.trx_mysql_thread_id AS waiting_thread,
@@ -34,12 +36,12 @@ export function createLocksResource(adapter: MySQLAdapter): ResourceDefinition {
                     JOIN information_schema.innodb_trx r ON r.trx_id = w.REQUESTING_ENGINE_TRANSACTION_ID
                     JOIN information_schema.innodb_trx b ON b.trx_id = w.BLOCKING_ENGINE_TRANSACTION_ID
                     LIMIT 20
-                `);
-
-        // Get global lock status
-        const lockStatusResult = await adapter.executeQuery(`
+                `),
+          // Get global lock status
+          adapter.executeQuery(`
                     SHOW STATUS LIKE 'Innodb_row_lock%'
-                `);
+                `),
+        ]);
 
         const lockStats: Record<string, unknown> = {};
         for (const row of lockStatusResult.rows ?? []) {

package/src/adapters/mysql/resources/performance.ts

@@ -23,8 +23,9 @@ export function createPerformanceResource(
       priority: 0.8,
     },
     handler: async (_uri: string, _context: RequestContext) => {
-      // Get performance-related status variables
-      const statusResult = await adapter.executeQuery(`
+      // Performance optimization: run both queries in parallel
+      // The performance_schema query may fail, but we handle that gracefully
+      const statusPromise = adapter.executeQuery(`
                 SHOW GLOBAL STATUS WHERE Variable_name IN (
                     'Queries', 'Questions', 'Slow_queries',
                     'Select_full_join', 'Select_range_check', 'Select_scan',
@@ -35,18 +36,9 @@ export function createPerformanceResource(
                 )
             `);
 
-      const status: Record<string, number> = {};
-      for (const row of statusResult.rows ?? []) {
-        status[row["Variable_name"] as string] = parseInt(
-          row["Value"] as string,
-          10,
-        );
-      }
-
-      // Get performance schema if available (MySQL 5.6+)
-      let topQueries: unknown[] = [];
-      try {
-        const perfResult = await adapter.executeQuery(`
+      const perfPromise = adapter
+        .executeQuery(
+          `
                     SELECT 
                         DIGEST_TEXT as query_pattern,
                         COUNT_STAR as execution_count,
@@ -59,12 +51,25 @@ export function createPerformanceResource(
                     WHERE DIGEST_TEXT IS NOT NULL
                     ORDER BY SUM_TIMER_WAIT DESC
                     LIMIT 10
-                `);
-        topQueries = perfResult.rows ?? [];
-      } catch {
-        // Performance schema may not be available
+                `,
+        )
+        .catch(() => ({ rows: [] as Record<string, unknown>[] }));
+
+      const [statusResult, perfResult] = await Promise.all([
+        statusPromise,
+        perfPromise,
+      ]);
+
+      const status: Record<string, number> = {};
+      for (const row of statusResult.rows ?? []) {
+        status[row["Variable_name"] as string] = parseInt(
+          row["Value"] as string,
+          10,
+        );
       }
 
+      const topQueries = perfResult.rows ?? [];
+
       // Calculate derived metrics
       const tmpTablesCreated = status["Created_tmp_tables"] ?? 0;
       const tmpDiskRatio =

package/src/adapters/mysql/resources/spatial.ts

@@ -21,8 +21,10 @@ export function createSpatialResource(
       priority: 0.5,
     },
     handler: async (_uri: string, _context: RequestContext) => {
-      // Get spatial columns
-      const columnsResult = await adapter.executeQuery(`
+      // Performance optimization: run both independent queries in parallel
+      const [columnsResult, indexesResult] = await Promise.all([
+        // Get spatial columns
+        adapter.executeQuery(`
                 SELECT 
                     TABLE_SCHEMA as schema_name,
                     TABLE_NAME as table_name,
@@ -34,10 +36,9 @@ export function createSpatialResource(
                                    'multipoint', 'multilinestring', 'multipolygon', 'geometrycollection')
                   AND TABLE_SCHEMA = DATABASE()
                 ORDER BY TABLE_NAME, COLUMN_NAME
-            `);
-
-      // Get spatial indexes
-      const indexesResult = await adapter.executeQuery(`
+            `),
+        // Get spatial indexes
+        adapter.executeQuery(`
                 SELECT 
                     TABLE_NAME as table_name,
                     INDEX_NAME as index_name,
@@ -46,7 +47,8 @@ export function createSpatialResource(
                 WHERE INDEX_TYPE = 'SPATIAL'
                   AND TABLE_SCHEMA = DATABASE()
                 ORDER BY TABLE_NAME, INDEX_NAME
-            `);
+            `),
+      ]);
 
       return {
         spatialColumnCount: columnsResult.rows?.length ?? 0,

package/src/adapters/mysql/resources/sysschema.ts

@@ -22,27 +22,28 @@ export function createSysSchemaResource(
     },
     handler: async (_uri: string, _context: RequestContext) => {
       try {
-        // Top resource consumers
-        const usersResult = await adapter.executeQuery(`
+        // Performance optimization: run all three independent queries in parallel
+        const [usersResult, statementsResult, locksResult] = await Promise.all([
+          // Top resource consumers
+          adapter.executeQuery(`
                     SELECT user, total_connections, current_connections, 
                            total_memory_allocated as memory_bytes
                     FROM sys.user_summary
                     ORDER BY total_memory_allocated DESC
                     LIMIT 5
-                `);
-
-        // Slow statements
-        const statementsResult = await adapter.executeQuery(`
+                `),
+          // Slow statements
+          adapter.executeQuery(`
                     SELECT SUBSTRING(query, 1, 100) as query_preview,
                            exec_count, total_latency, avg_latency
                     FROM sys.statements_with_runtimes_in_95th_percentile
                     LIMIT 5
-                `);
-
-        // Current lock waits
-        const locksResult = await adapter.executeQuery(`
+                `),
+          // Current lock waits
+          adapter.executeQuery(`
                     SELECT COUNT(*) as lock_wait_count FROM sys.innodb_lock_waits
-                `);
+                `),
+        ]);
         const lockRow = locksResult.rows?.[0];
 
         return {

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

@@ -300,6 +300,16 @@ describe("Handler Execution", () => {
 
       expect(mockAdapter.listTables).toHaveBeenCalled();
     });
+
+    it("should return exists: false for nonexistent database", async () => {
+      mockAdapter.executeReadQuery.mockResolvedValue(createMockQueryResult([]));
+
+      const tool = tools.find((t) => t.name === "mysql_list_tables")!;
+      const result = await tool.handler({ database: "fake_db" }, mockContext);
+
+      expect(result).toHaveProperty("exists", false);
+      expect(result).toHaveProperty("database", "fake_db");
+    });
   });
 
   describe("mysql_describe_table", () => {
@@ -380,6 +390,7 @@ describe("Handler Execution", () => {
     });
 
     it("should handle IF NOT EXISTS clause", async () => {
+      mockAdapter.describeTable.mockResolvedValue({ columns: [] });
       mockAdapter.executeQuery.mockResolvedValue({ rows: [], rowsAffected: 0 });
 
       const tool = tools.find((t) => t.name === "mysql_create_table")!;
@@ -458,25 +469,49 @@ describe("Handler Execution", () => {
 
       expect(result).toHaveProperty("success", false);
       expect(result).toHaveProperty(
-        "reason",
+        "error",
         "Table 'test_table' already exists",
       );
     });
 
-    it("should re-throw non-existence errors in create table", async () => {
+    it("should return structured error for non-existence errors in create table", async () => {
       mockAdapter.executeQuery.mockRejectedValue(new Error("Access denied"));
 
       const tool = tools.find((t) => t.name === "mysql_create_table")!;
+      const result = await tool.handler(
+        {
+          name: "test_table",
+          columns: [{ name: "id", type: "INT" }],
+        },
+        mockContext,
+      );
 
-      await expect(
-        tool.handler(
-          {
-            name: "test_table",
-            columns: [{ name: "id", type: "INT" }],
-          },
-          mockContext,
-        ),
-      ).rejects.toThrow("Access denied");
+      expect(result).toHaveProperty("success", false);
+      expect((result as Record<string, unknown>).error).toContain(
+        "Access denied",
+      );
+    });
+
+    it("should return skipped indicator when ifNotExists is true and table exists", async () => {
+      mockAdapter.describeTable.mockResolvedValue({
+        columns: [{ name: "id", type: "int" }],
+      });
+
+      const tool = tools.find((t) => t.name === "mysql_create_table")!;
+      const result = await tool.handler(
+        {
+          name: "existing_table",
+          columns: [{ name: "id", type: "INT" }],
+          ifNotExists: true,
+        },
+        mockContext,
+      );
+
+      expect(result).toHaveProperty("success", true);
+      expect(result).toHaveProperty("skipped", true);
+      expect(result).toHaveProperty("reason", "Table already exists");
+      // Should NOT call executeQuery since it short-circuits
+      expect(mockAdapter.executeQuery).not.toHaveBeenCalled();
     });
   });
 
@@ -503,12 +538,14 @@ describe("Handler Execution", () => {
       expect(sqlCall).toContain("IF EXISTS");
     });
 
-    it("should reject invalid table names", async () => {
+    it("should return structured error for invalid table names", async () => {
       const tool = tools.find((t) => t.name === "mysql_drop_table")!;
+      const result = await tool.handler({ table: "invalid-name" }, mockContext);
 
-      await expect(
-        tool.handler({ table: "invalid-name" }, mockContext),
-      ).rejects.toThrow("Invalid table name");
+      expect(result).toHaveProperty("success", false);
+      expect((result as Record<string, unknown>).error).toBe(
+        "Invalid table name",
+      );
     });
 
     it("should handle qualified table names", async () => {
@@ -518,7 +555,7 @@ describe("Handler Execution", () => {
       await tool.handler({ table: "db.table" }, mockContext);
 
       const sqlCall = mockAdapter.executeQuery.mock.calls[0]?.[0] as string;
-      expect(sqlCall).toContain("DROP TABLE IF EXISTS `db`.`table`");
+      expect(sqlCall).toContain("DROP TABLE `db`.`table`");
     });
 
     it("should return graceful error when table does not exist", async () => {
@@ -534,7 +571,7 @@ describe("Handler Execution", () => {
 
       expect(result).toHaveProperty("success", false);
       expect(result).toHaveProperty(
-        "reason",
+        "error",
         "Table 'nonexistent' does not exist",
       );
     });
@@ -554,14 +591,19 @@ describe("Handler Execution", () => {
       expect(result).toHaveProperty("reason", "Table did not exist");
     });
 
-    it("should re-throw non-existence errors in drop table", async () => {
+    it("should return structured error for non-existence errors in drop table", async () => {
       mockAdapter.executeQuery.mockRejectedValue(new Error("Access denied"));
 
       const tool = tools.find((t) => t.name === "mysql_drop_table")!;
+      const result = await tool.handler(
+        { table: "some_table", ifExists: false },
+        mockContext,
+      );
 
-      await expect(
-        tool.handler({ table: "some_table", ifExists: false }, mockContext),
-      ).rejects.toThrow("Access denied");
+      expect(result).toHaveProperty("success", false);
+      expect((result as Record<string, unknown>).error).toContain(
+        "Access denied",
+      );
     });
   });
 
@@ -629,34 +671,38 @@ describe("Handler Execution", () => {
       expect(mockAdapter.executeQuery).not.toHaveBeenCalled();
     });
 
-    it("should reject invalid index names", async () => {
+    it("should return structured error for invalid index names", async () => {
       const tool = tools.find((t) => t.name === "mysql_create_index")!;
+      const result = await tool.handler(
+        {
+          name: "invalid-name",
+          table: "users",
+          columns: ["email"],
+        },
+        mockContext,
+      );
 
-      await expect(
-        tool.handler(
-          {
-            name: "invalid-name",
-            table: "users",
-            columns: ["email"],
-          },
-          mockContext,
-        ),
-      ).rejects.toThrow("Invalid index name");
+      expect(result).toHaveProperty("success", false);
+      expect((result as Record<string, unknown>).error).toBe(
+        "Invalid index name",
+      );
     });
 
-    it("should reject invalid table names", async () => {
+    it("should return structured error for invalid table names", async () => {
       const tool = tools.find((t) => t.name === "mysql_create_index")!;
+      const result = await tool.handler(
+        {
+          name: "valid_name",
+          table: "invalid-table",
+          columns: ["email"],
+        },
+        mockContext,
+      );
 
-      await expect(
-        tool.handler(
-          {
-            name: "valid_name",
-            table: "invalid-table",
-            columns: ["email"],
-          },
-          mockContext,
-        ),
-      ).rejects.toThrow("Invalid table name");
+      expect(result).toHaveProperty("success", false);
+      expect((result as Record<string, unknown>).error).toBe(
+        "Invalid table name",
+      );
     });
 
     it("should handle qualified table names", async () => {
@@ -714,7 +760,7 @@ describe("Handler Execution", () => {
 
       expect(result).toHaveProperty("success", false);
       expect(result).toHaveProperty(
-        "reason",
+        "error",
         "Index 'idx_existing' already exists on table 'users'",
       );
     });
@@ -738,21 +784,46 @@ describe("Handler Execution", () => {
       expect(result).toHaveProperty("table", "nonexistent");
     });
 
-    it("should re-throw non-index errors in create index", async () => {
+    it("should return structured error for non-index errors in create index", async () => {
       mockAdapter.executeQuery.mockRejectedValue(new Error("Access denied"));
 
       const tool = tools.find((t) => t.name === "mysql_create_index")!;
+      const result = await tool.handler(
+        {
+          name: "idx_test",
+          table: "users",
+          columns: ["email"],
+        },
+        mockContext,
+      );
+
+      expect(result).toHaveProperty("success", false);
+      expect((result as Record<string, unknown>).error).toContain(
+        "Access denied",
+      );
+    });
+
+    it("should return column-specific error for invalid column names", async () => {
+      mockAdapter.executeQuery.mockRejectedValue(
+        new Error("Key column 'nonexistent_col' doesn't exist in table"),
+      );
+
+      const tool = tools.find((t) => t.name === "mysql_create_index")!;
+      const result = await tool.handler(
+        {
+          name: "idx_test",
+          table: "users",
+          columns: ["nonexistent_col"],
+        },
+        mockContext,
+      );
 
-      await expect(
-        tool.handler(
-          {
-            name: "idx_test",
-            table: "users",
-            columns: ["email"],
-          },
-          mockContext,
-        ),
-      ).rejects.toThrow("Access denied");
+      expect(result).toHaveProperty("success", false);
+      expect((result as Record<string, unknown>).error).toContain(
+        "Column 'nonexistent_col' does not exist",
+      );
+      // Should NOT return exists: false (table exists, column doesn't)
+      expect(result).not.toHaveProperty("exists", false);
     });
   });
 });