@neverinfamous/mysql-mcp 2.1.0 → 2.3.0

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

@@ -1,62 +1,101 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { createSysSchemaResource } from "../sysschema.js";
+import type { MySQLAdapter } from "../../MySQLAdapter.js";
+import {
+  createMockMySQLAdapter,
+  createMockRequestContext,
+  createMockQueryResult,
+} from "../../../../__tests__/mocks/index.js";
 
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { createSysSchemaResource } from '../sysschema.js';
-import type { MySQLAdapter } from '../../MySQLAdapter.js';
-import { createMockMySQLAdapter, createMockRequestContext, createMockQueryResult } from '../../../../__tests__/mocks/index.js';
-
-describe('SysSchema Resource', () => {
-    let mockAdapter: ReturnType<typeof createMockMySQLAdapter>;
-    let mockContext: ReturnType<typeof createMockRequestContext>;
-
-    beforeEach(() => {
-        vi.clearAllMocks();
-        mockAdapter = createMockMySQLAdapter();
-        mockContext = createMockRequestContext();
-    });
-
-    it('should return sys schema diagnostics when available', async () => {
-        // Mock top users query
-        mockAdapter.executeQuery.mockResolvedValueOnce(createMockQueryResult([
-            { user: 'root', total_connections: 100, current_connections: 5, memory_bytes: 1000000 }
-        ]));
-        // Mock slow statements query
-        mockAdapter.executeQuery.mockResolvedValueOnce(createMockQueryResult([
-            { query_preview: 'SELECT * FROM large_table', exec_count: 50, total_latency: '5s' }
-        ]));
-        // Mock lock waits query
-        mockAdapter.executeQuery.mockResolvedValueOnce(createMockQueryResult([
-            { lock_wait_count: 0 }
-        ]));
-
-        const resource = createSysSchemaResource(mockAdapter as unknown as MySQLAdapter);
-        const result = await resource.handler('mysql://sysschema', mockContext) as { available: boolean; topUsers: unknown[] };
-
-        expect(result).toHaveProperty('available', true);
-        expect(result).toHaveProperty('topUsers');
-        expect(result).toHaveProperty('slowStatements');
-        expect(result).toHaveProperty('currentLockWaits', 0);
-    });
-
-    it('should handle sys schema not available', async () => {
-        mockAdapter.executeQuery.mockRejectedValueOnce(new Error('sys schema not found'));
-
-        const resource = createSysSchemaResource(mockAdapter as unknown as MySQLAdapter);
-        const result = await resource.handler('mysql://sysschema', mockContext) as { available: boolean; message: string };
-
-        expect(result.available).toBe(false);
-        expect(result).toHaveProperty('message');
-    });
-
-    it('should handle null query results', async () => {
-        mockAdapter.executeQuery.mockResolvedValueOnce(createMockQueryResult(null as any)); // Users
-        mockAdapter.executeQuery.mockResolvedValueOnce(createMockQueryResult(null as any)); // Statements
-        mockAdapter.executeQuery.mockResolvedValueOnce(createMockQueryResult(null as any)); // Locks
-
-        const resource = createSysSchemaResource(mockAdapter as unknown as MySQLAdapter);
-        const result = await resource.handler('mysql://sysschema', mockContext) as any;
-
-        expect(result.topUsers).toEqual([]);
-        expect(result.slowStatements).toEqual([]);
-        expect(result.currentLockWaits).toBe(0);
-    });
+describe("SysSchema Resource", () => {
+  let mockAdapter: ReturnType<typeof createMockMySQLAdapter>;
+  let mockContext: ReturnType<typeof createMockRequestContext>;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mockAdapter = createMockMySQLAdapter();
+    mockContext = createMockRequestContext();
+  });
+
+  it("should return sys schema diagnostics when available", async () => {
+    // Mock top users query
+    mockAdapter.executeQuery.mockResolvedValueOnce(
+      createMockQueryResult([
+        {
+          user: "root",
+          total_connections: 100,
+          current_connections: 5,
+          memory_bytes: 1000000,
+        },
+      ]),
+    );
+    // Mock slow statements query
+    mockAdapter.executeQuery.mockResolvedValueOnce(
+      createMockQueryResult([
+        {
+          query_preview: "SELECT * FROM large_table",
+          exec_count: 50,
+          total_latency: "5s",
+        },
+      ]),
+    );
+    // Mock lock waits query
+    mockAdapter.executeQuery.mockResolvedValueOnce(
+      createMockQueryResult([{ lock_wait_count: 0 }]),
+    );
+
+    const resource = createSysSchemaResource(
+      mockAdapter as unknown as MySQLAdapter,
+    );
+    const result = (await resource.handler(
+      "mysql://sysschema",
+      mockContext,
+    )) as { available: boolean; topUsers: unknown[] };
+
+    expect(result).toHaveProperty("available", true);
+    expect(result).toHaveProperty("topUsers");
+    expect(result).toHaveProperty("slowStatements");
+    expect(result).toHaveProperty("currentLockWaits", 0);
+  });
+
+  it("should handle sys schema not available", async () => {
+    mockAdapter.executeQuery.mockRejectedValueOnce(
+      new Error("sys schema not found"),
+    );
+
+    const resource = createSysSchemaResource(
+      mockAdapter as unknown as MySQLAdapter,
+    );
+    const result = (await resource.handler(
+      "mysql://sysschema",
+      mockContext,
+    )) as { available: boolean; message: string };
+
+    expect(result.available).toBe(false);
+    expect(result).toHaveProperty("message");
+  });
+
+  it("should handle null query results", async () => {
+    mockAdapter.executeQuery.mockResolvedValueOnce(
+      createMockQueryResult(null as any),
+    ); // Users
+    mockAdapter.executeQuery.mockResolvedValueOnce(
+      createMockQueryResult(null as any),
+    ); // Statements
+    mockAdapter.executeQuery.mockResolvedValueOnce(
+      createMockQueryResult(null as any),
+    ); // Locks
+
+    const resource = createSysSchemaResource(
+      mockAdapter as unknown as MySQLAdapter,
+    );
+    const result = (await resource.handler(
+      "mysql://sysschema",
+      mockContext,
+    )) as any;
+
+    expect(result.topUsers).toEqual([]);
+    expect(result.slowStatements).toEqual([]);
+    expect(result.currentLockWaits).toBe(0);
+  });
 });

package/src/adapters/mysql/resources/__tests__/tables.test.ts

@@ -1,37 +1,46 @@
-
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { createTablesResource } from '../tables.js';
-import type { MySQLAdapter } from '../../MySQLAdapter.js';
-import { createMockMySQLAdapter, createMockRequestContext } from '../../../../__tests__/mocks/index.js';
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { createTablesResource } from "../tables.js";
+import type { MySQLAdapter } from "../../MySQLAdapter.js";
+import {
+  createMockMySQLAdapter,
+  createMockRequestContext,
+} from "../../../../__tests__/mocks/index.js";
 
 interface TablesResult {
-    tables: unknown[];
-    count: number;
+  tables: unknown[];
+  count: number;
 }
 
-describe('Tables Resource', () => {
-    let mockAdapter: ReturnType<typeof createMockMySQLAdapter>;
-    let mockContext: ReturnType<typeof createMockRequestContext>;
-
-    beforeEach(() => {
-        vi.clearAllMocks();
-        mockAdapter = createMockMySQLAdapter();
-        mockContext = createMockRequestContext();
-    });
-
-    it('should call listTables adapter method', async () => {
-        const resource = createTablesResource(mockAdapter as unknown as MySQLAdapter);
-        await resource.handler('mysql://tables', mockContext);
-
-        expect(mockAdapter.listTables).toHaveBeenCalled();
-    });
-
-    it('should return table list with count', async () => {
-        const resource = createTablesResource(mockAdapter as unknown as MySQLAdapter);
-        const result = await resource.handler('mysql://tables', mockContext) as TablesResult;
-
-        expect(result).toHaveProperty('tables');
-        expect(result).toHaveProperty('count');
-        expect(Array.isArray(result.tables)).toBe(true);
-    });
+describe("Tables Resource", () => {
+  let mockAdapter: ReturnType<typeof createMockMySQLAdapter>;
+  let mockContext: ReturnType<typeof createMockRequestContext>;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mockAdapter = createMockMySQLAdapter();
+    mockContext = createMockRequestContext();
+  });
+
+  it("should call listTables adapter method", async () => {
+    const resource = createTablesResource(
+      mockAdapter as unknown as MySQLAdapter,
+    );
+    await resource.handler("mysql://tables", mockContext);
+
+    expect(mockAdapter.listTables).toHaveBeenCalled();
+  });
+
+  it("should return table list with count", async () => {
+    const resource = createTablesResource(
+      mockAdapter as unknown as MySQLAdapter,
+    );
+    const result = (await resource.handler(
+      "mysql://tables",
+      mockContext,
+    )) as TablesResult;
+
+    expect(result).toHaveProperty("tables");
+    expect(result).toHaveProperty("count");
+    expect(Array.isArray(result.tables)).toBe(true);
+  });
 });

package/src/adapters/mysql/resources/__tests__/variables.test.ts

@@ -1,70 +1,98 @@
 /**
  * mysql-mcp - Variables Resource Unit Tests
- * 
+ *
  * Tests for variables resource handler execution.
  */
 
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { createMockMySQLAdapter, createMockQueryResult, createMockRequestContext } from '../../../../__tests__/mocks/index.js';
-import type { MySQLAdapter } from '../../MySQLAdapter.js';
-import { createVariablesResource } from '../variables.js';
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import {
+  createMockMySQLAdapter,
+  createMockQueryResult,
+  createMockRequestContext,
+} from "../../../../__tests__/mocks/index.js";
+import type { MySQLAdapter } from "../../MySQLAdapter.js";
+import { createVariablesResource } from "../variables.js";
 
-describe('Variables Resource', () => {
-    let mockAdapter: ReturnType<typeof createMockMySQLAdapter>;
-    let mockContext: ReturnType<typeof createMockRequestContext>;
+describe("Variables Resource", () => {
+  let mockAdapter: ReturnType<typeof createMockMySQLAdapter>;
+  let mockContext: ReturnType<typeof createMockRequestContext>;
 
-    beforeEach(() => {
-        vi.clearAllMocks();
-        mockAdapter = createMockMySQLAdapter();
-        mockContext = createMockRequestContext();
-    });
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mockAdapter = createMockMySQLAdapter();
+    mockContext = createMockRequestContext();
+  });
 
-    it('should return all global variables', async () => {
-        mockAdapter.executeQuery.mockResolvedValueOnce(createMockQueryResult([
-            { Variable_name: 'max_connections', Value: '151' },
-            { Variable_name: 'innodb_buffer_pool_size', Value: '134217728' }
-        ]));
+  it("should return all global variables", async () => {
+    mockAdapter.executeQuery.mockResolvedValueOnce(
+      createMockQueryResult([
+        { Variable_name: "max_connections", Value: "151" },
+        { Variable_name: "innodb_buffer_pool_size", Value: "134217728" },
+      ]),
+    );
 
-        const resource = createVariablesResource(mockAdapter as unknown as MySQLAdapter);
-        const result = await resource.handler('mysql://variables', mockContext) as { variables: Record<string, string> };
+    const resource = createVariablesResource(
+      mockAdapter as unknown as MySQLAdapter,
+    );
+    const result = (await resource.handler(
+      "mysql://variables",
+      mockContext,
+    )) as { variables: Record<string, string> };
 
-        expect(result.variables).toEqual({
-            max_connections: '151',
-            innodb_buffer_pool_size: '134217728'
-        });
-        expect(mockAdapter.executeQuery).toHaveBeenCalledWith('SHOW GLOBAL VARIABLES');
+    expect(result.variables).toEqual({
+      max_connections: "151",
+      innodb_buffer_pool_size: "134217728",
     });
+    expect(mockAdapter.executeQuery).toHaveBeenCalledWith(
+      "SHOW GLOBAL VARIABLES",
+    );
+  });
+
+  it("should handle empty result set", async () => {
+    mockAdapter.executeQuery.mockResolvedValueOnce(createMockQueryResult([]));
 
-    it('should handle empty result set', async () => {
-        mockAdapter.executeQuery.mockResolvedValueOnce(createMockQueryResult([]));
+    const resource = createVariablesResource(
+      mockAdapter as unknown as MySQLAdapter,
+    );
+    const result = (await resource.handler(
+      "mysql://variables",
+      mockContext,
+    )) as { variables: Record<string, string> };
 
-        const resource = createVariablesResource(mockAdapter as unknown as MySQLAdapter);
-        const result = await resource.handler('mysql://variables', mockContext) as { variables: Record<string, string> };
+    expect(result.variables).toEqual({});
+  });
 
-        expect(result.variables).toEqual({});
+  it("should handle missing rows property in result", async () => {
+    mockAdapter.executeQuery.mockResolvedValueOnce({
+      columns: [],
+      rowsAffected: 0,
+      insertId: undefined,
+      start_time: 0,
+      executionTimeMs: 0,
     });
 
-    it('should handle missing rows property in result', async () => {
-        mockAdapter.executeQuery.mockResolvedValueOnce({
-            columns: [],
-            rowsAffected: 0,
-            insertId: undefined,
-            start_time: 0,
-            executionTimeMs: 0
-        });
+    const resource = createVariablesResource(
+      mockAdapter as unknown as MySQLAdapter,
+    );
+    const result = (await resource.handler(
+      "mysql://variables",
+      mockContext,
+    )) as { variables: Record<string, string> };
 
-        const resource = createVariablesResource(mockAdapter as unknown as MySQLAdapter);
-        const result = await resource.handler('mysql://variables', mockContext) as { variables: Record<string, string> };
+    expect(result.variables).toEqual({});
+  });
 
-        expect(result.variables).toEqual({});
-    });
+  it("should handle database errors", async () => {
+    mockAdapter.executeQuery.mockRejectedValueOnce(
+      new Error("Connection failed"),
+    );
 
-    it('should handle database errors', async () => {
-        mockAdapter.executeQuery.mockRejectedValueOnce(new Error('Connection failed'));
+    const resource = createVariablesResource(
+      mockAdapter as unknown as MySQLAdapter,
+    );
 
-        const resource = createVariablesResource(mockAdapter as unknown as MySQLAdapter);
-        
-        await expect(resource.handler('mysql://variables', mockContext))
-            .rejects.toThrow('Connection failed');
-    });
+    await expect(
+      resource.handler("mysql://variables", mockContext),
+    ).rejects.toThrow("Connection failed");
+  });
 });

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

@@ -1,51 +1,70 @@
 /**
  * MySQL Resource - Capabilities
- * 
+ *
  * Provides server version, available features, and tool categories.
  */
-import type { MySQLAdapter } from '../MySQLAdapter.js';
-import type { ResourceDefinition, RequestContext } from '../../../types/index.js';
-import { TOOL_GROUPS, META_GROUPS, getMetaGroupInfo, getToolGroupInfo } from '../../../filtering/ToolFilter.js';
+import type { MySQLAdapter } from "../MySQLAdapter.js";
+import type {
+  ResourceDefinition,
+  RequestContext,
+} from "../../../types/index.js";
+import {
+  TOOL_GROUPS,
+  META_GROUPS,
+  getMetaGroupInfo,
+  getToolGroupInfo,
+} from "../../../filtering/ToolFilter.js";
 
-export function createCapabilitiesResource(adapter: MySQLAdapter): ResourceDefinition {
-    return {
-        uri: 'mysql://capabilities',
-        name: 'Server Capabilities',
-        title: 'MySQL Server Capabilities',
-        description: 'MySQL server version, extensions, and available tool categories',
-        mimeType: 'application/json',
-        annotations: {
-            audience: ['user', 'assistant'],
-            priority: 0.9
-        },
-        handler: async (_uri: string, _context: RequestContext) => {
-            // Get server version
-            const versionResult = await adapter.executeQuery('SELECT VERSION() as version');
-            const version = (versionResult.rows?.[0]?.['version'] as string) ?? 'unknown';
+export function createCapabilitiesResource(
+  adapter: MySQLAdapter,
+): ResourceDefinition {
+  return {
+    uri: "mysql://capabilities",
+    name: "Server Capabilities",
+    title: "MySQL Server Capabilities",
+    description:
+      "MySQL server version, extensions, and available tool categories",
+    mimeType: "application/json",
+    annotations: {
+      audience: ["user", "assistant"],
+      priority: 0.9,
+    },
+    handler: async (_uri: string, _context: RequestContext) => {
+      // Get server version
+      const versionResult = await adapter.executeQuery(
+        "SELECT VERSION() as version",
+      );
+      const version =
+        (versionResult.rows?.[0]?.["version"] as string) ?? "unknown";
+
+      // Parse major version for feature detection (handles 8.x, 9.x, 10.x+)
+      const majorVersion = parseInt(version.split(".")[0] ?? "0", 10) || 0;
 
-            // Get available features
-            const features = {
-                json: version.startsWith('5.7') || version.startsWith('8.'),
-                fulltext: true,
-                partitioning: true,
-                replication: true,
-                gtid: version.startsWith('5.6') || version.startsWith('5.7') || version.startsWith('8.')
-            };
+      const features = {
+        json: majorVersion >= 8 || version.startsWith("5.7"),
+        fulltext: true,
+        partitioning: true,
+        replication: true,
+        gtid:
+          majorVersion >= 8 ||
+          version.startsWith("5.6") ||
+          version.startsWith("5.7"),
+      };
 
-            // Get tool groups and meta-groups info
-            const toolGroupList = getToolGroupInfo();
-            const metaGroupList = getMetaGroupInfo();
+      // Get tool groups and meta-groups info
+      const toolGroupList = getToolGroupInfo();
+      const metaGroupList = getMetaGroupInfo();
 
-            return {
-                server: {
-                    version,
-                    features
-                },
-                toolCategoryCount: Object.keys(TOOL_GROUPS).length,
-                metaGroupCount: Object.keys(META_GROUPS).length,
-                toolGroups: toolGroupList,
-                metaGroups: metaGroupList
-            };
-        }
-    };
+      return {
+        server: {
+          version,
+          features,
+        },
+        toolCategoryCount: Object.keys(TOOL_GROUPS).length,
+        metaGroupCount: Object.keys(META_GROUPS).length,
+        toolGroups: toolGroupList,
+        metaGroups: metaGroupList,
+      };
+    },
+  };
 }

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

@@ -1,39 +1,45 @@
 /**
  * MySQL Resource - Cluster
  */
-import type { MySQLAdapter } from '../MySQLAdapter.js';
-import type { ResourceDefinition, RequestContext } from '../../../types/index.js';
+import type { MySQLAdapter } from "../MySQLAdapter.js";
+import type {
+  ResourceDefinition,
+  RequestContext,
+} from "../../../types/index.js";
 
-export function createClusterResource(adapter: MySQLAdapter): ResourceDefinition {
-    return {
-        uri: 'mysql://cluster',
-        name: 'Cluster Status',
-        title: 'MySQL Group Replication / InnoDB Cluster',
-        description: 'Group Replication and InnoDB Cluster status overview',
-        mimeType: 'application/json',
-        annotations: {
-            audience: ['user', 'assistant'],
-            priority: 0.7
-        },
-        handler: async (_uri: string, _context: RequestContext) => {
-            try {
-                // Check if Group Replication is enabled
-                const grStatusResult = await adapter.executeQuery(
-                    "SHOW VARIABLES LIKE 'group_replication_group_name'"
-                );
-                const grRow = grStatusResult.rows?.[0];
-                const groupNameVal = grRow?.['Value'];
-                const groupName = typeof groupNameVal === 'string' ? groupNameVal : null;
+export function createClusterResource(
+  adapter: MySQLAdapter,
+): ResourceDefinition {
+  return {
+    uri: "mysql://cluster",
+    name: "Cluster Status",
+    title: "MySQL Group Replication / InnoDB Cluster",
+    description: "Group Replication and InnoDB Cluster status overview",
+    mimeType: "application/json",
+    annotations: {
+      audience: ["user", "assistant"],
+      priority: 0.7,
+    },
+    handler: async (_uri: string, _context: RequestContext) => {
+      try {
+        // Check if Group Replication is enabled
+        const grStatusResult = await adapter.executeQuery(
+          "SHOW VARIABLES LIKE 'group_replication_group_name'",
+        );
+        const grRow = grStatusResult.rows?.[0];
+        const groupNameVal = grRow?.["Value"];
+        const groupName =
+          typeof groupNameVal === "string" ? groupNameVal : null;
 
-                if (groupName === null || groupName === '') {
-                    return {
-                        groupReplicationEnabled: false,
-                        message: 'Group Replication is not configured'
-                    };
-                }
+        if (groupName === null || groupName === "") {
+          return {
+            groupReplicationEnabled: false,
+            message: "Group Replication is not configured",
+          };
+        }
 
-                // Get members
-                const membersResult = await adapter.executeQuery(`
+        // Get members
+        const membersResult = await adapter.executeQuery(`
                     SELECT 
                         MEMBER_ID as id,
                         MEMBER_HOST as host,
@@ -44,28 +50,31 @@ export function createClusterResource(adapter: MySQLAdapter): ResourceDefinition
                     FROM performance_schema.replication_group_members
                 `);
 
-                // Get primary
-                const primaryResult = await adapter.executeQuery(`
+        // Get primary
+        const primaryResult = await adapter.executeQuery(`
                     SELECT MEMBER_HOST as host, MEMBER_PORT as port
                     FROM performance_schema.replication_group_members
                     WHERE MEMBER_ROLE = 'PRIMARY'
                 `);
-                const primaryRow = primaryResult.rows?.[0];
+        const primaryRow = primaryResult.rows?.[0];
 
-                return {
-                    groupReplicationEnabled: true,
-                    groupName,
-                    memberCount: membersResult.rows?.length ?? 0,
-                    members: membersResult.rows ?? [],
-                    primary: primaryRow ? `${String(primaryRow['host'])}:${String(primaryRow['port'])}` : null
-                };
-            } catch {
-                return {
-                    groupReplicationEnabled: false,
-                    message: 'Unable to retrieve cluster information',
-                    suggestion: 'Group Replication may not be configured or insufficient privileges'
-                };
-            }
-        }
-    };
+        return {
+          groupReplicationEnabled: true,
+          groupName,
+          memberCount: membersResult.rows?.length ?? 0,
+          members: membersResult.rows ?? [],
+          primary: primaryRow
+            ? `${String(primaryRow["host"])}:${String(primaryRow["port"])}`
+            : null,
+        };
+      } catch {
+        return {
+          groupReplicationEnabled: false,
+          message: "Unable to retrieve cluster information",
+          suggestion:
+            "Group Replication may not be configured or insufficient privileges",
+        };
+      }
+    },
+  };
 }