@neverinfamous/mysql-mcp 2.1.0 → 2.3.0

package/src/__tests__/cli.test.ts

@@ -1,304 +1,359 @@
-
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { main } from '../cli.js';
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { main } from "../cli.js";
 
 // Hoist mocks to be accessible in vi.mock factory
 const mocks = vi.hoisted(() => ({
-    createServer: vi.fn(),
-    MySQLAdapter: vi.fn(),
-    serverInstance: {
-        start: vi.fn(),
-        stop: vi.fn(),
-        registerAdapter: vi.fn()
-    },
-    adapterInstance: {
-        connect: vi.fn()
-    }
+  createServer: vi.fn(),
+  MySQLAdapter: vi.fn(),
+  serverInstance: {
+    start: vi.fn(),
+    stop: vi.fn(),
+    registerAdapter: vi.fn(),
+  },
+  adapterInstance: {
+    connect: vi.fn(),
+  },
 }));
 
 // Mock McpServer partially
-vi.mock('../server/McpServer.js', async (importOriginal) => {
-    const actual = await importOriginal<typeof import('../server/McpServer.js')>();
-    return {
-        ...actual,
-        createServer: mocks.createServer
-    };
+vi.mock("../server/McpServer.js", async (importOriginal) => {
+  const actual =
+    await importOriginal<typeof import("../server/McpServer.js")>();
+  return {
+    ...actual,
+    createServer: mocks.createServer,
+  };
 });
 
 // Mock MySQLAdapter
-vi.mock('../adapters/mysql/MySQLAdapter.js', () => ({
-    MySQLAdapter: mocks.MySQLAdapter
+vi.mock("../adapters/mysql/MySQLAdapter.js", () => ({
+  MySQLAdapter: mocks.MySQLAdapter,
 }));
 
 // Mock process.exit
-const mockExit = vi.spyOn(process, 'exit').mockImplementation((code?: number | string | null | undefined) => {
+const mockExit = vi
+  .spyOn(process, "exit")
+  .mockImplementation((code?: number | string | null | undefined) => {
     throw new Error(`process.exit(${code})`);
-});
+  });
 
 // Mock console.error
-const mockConsoleError = vi.spyOn(console, 'error').mockImplementation(() => { });
+const mockConsoleError = vi
+  .spyOn(console, "error")
+  .mockImplementation(() => {});
 
 // Fix: Use a regular function for implementation so it can be called with 'new'
 const mockMySQLAdapterImplementation = function () {
-    return mocks.adapterInstance;
+  return mocks.adapterInstance;
 };
 
-describe('CLI', () => {
-    beforeEach(() => {
-        vi.clearAllMocks();
-
-        // Setup default mock behaviors
-        mocks.createServer.mockReturnValue(mocks.serverInstance);
-        // Set implementation for MySQLAdapter (class constructor mock)
-        mocks.MySQLAdapter.mockImplementation(mockMySQLAdapterImplementation);
-
-        mocks.serverInstance.start.mockResolvedValue(undefined);
-        mocks.serverInstance.stop.mockResolvedValue(undefined);
-        mocks.adapterInstance.connect.mockResolvedValue(undefined);
-
-        delete process.env['MYSQL_HOST'];
-        delete process.env['MYSQL_USER'];
-        delete process.env['MYSQL_PASSWORD'];
-        delete process.env['MYSQL_DATABASE'];
-        delete process.env['MYSQL_MCP_TOOL_FILTER'];
-        delete process.env['OAUTH_ENABLED'];
+describe("CLI", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+
+    // Setup default mock behaviors
+    mocks.createServer.mockReturnValue(mocks.serverInstance);
+    // Set implementation for MySQLAdapter (class constructor mock)
+    mocks.MySQLAdapter.mockImplementation(mockMySQLAdapterImplementation);
+
+    mocks.serverInstance.start.mockResolvedValue(undefined);
+    mocks.serverInstance.stop.mockResolvedValue(undefined);
+    mocks.adapterInstance.connect.mockResolvedValue(undefined);
+
+    delete process.env["MYSQL_HOST"];
+    delete process.env["MYSQL_USER"];
+    delete process.env["MYSQL_PASSWORD"];
+    delete process.env["MYSQL_DATABASE"];
+    delete process.env["MYSQL_MCP_TOOL_FILTER"];
+    delete process.env["OAUTH_ENABLED"];
+  });
+
+  describe("canSkipMySQLConnection logic", () => {
+    it("should skip MySQL connection for router-only filter", async () => {
+      await main({
+        config: { toolFilter: "router" },
+        databases: [
+          { type: "mysql", host: "localhost", database: "test" } as any,
+        ],
+        oauth: undefined,
+      });
+
+      // Should NOT call connect because router tools don't need MySQL
+      expect(mocks.adapterInstance.connect).not.toHaveBeenCalled();
+      expect(mocks.serverInstance.registerAdapter).toHaveBeenCalled();
     });
 
-    describe('canSkipMySQLConnection logic', () => {
-        it('should skip MySQL connection for router-only filter', async () => {
-            await main({
-                config: { toolFilter: 'router' },
-                databases: [{ type: 'mysql', host: 'localhost', database: 'test' } as any],
-                oauth: undefined
-            });
-
-            // Should NOT call connect because router tools don't need MySQL
-            expect(mocks.adapterInstance.connect).not.toHaveBeenCalled();
-            expect(mocks.serverInstance.registerAdapter).toHaveBeenCalled();
-        });
-
-        it('should skip MySQL connection for proxysql-only filter', async () => {
-            await main({
-                config: { toolFilter: 'proxysql' },
-                databases: [{ type: 'mysql', host: 'localhost', database: 'test' } as any],
-                oauth: undefined
-            });
-
-            expect(mocks.adapterInstance.connect).not.toHaveBeenCalled();
-        });
-
-        it('should skip MySQL connection for shell-only filter', async () => {
-            await main({
-                config: { toolFilter: 'shell' },
-                databases: [{ type: 'mysql', host: 'localhost', database: 'test' } as any],
-                oauth: undefined
-            });
-
-            expect(mocks.adapterInstance.connect).not.toHaveBeenCalled();
-        });
-
-        it('should skip MySQL connection for ecosystem shortcut', async () => {
-            await main({
-                config: { toolFilter: 'ecosystem' },
-                databases: [{ type: 'mysql', host: 'localhost', database: 'test' } as any],
-                oauth: undefined
-            });
-
-            expect(mocks.adapterInstance.connect).not.toHaveBeenCalled();
-        });
+    it("should skip MySQL connection for proxysql-only filter", async () => {
+      await main({
+        config: { toolFilter: "proxysql" },
+        databases: [
+          { type: "mysql", host: "localhost", database: "test" } as any,
+        ],
+        oauth: undefined,
+      });
 
-        it('should skip MySQL connection for combined MySQL-optional groups', async () => {
-            await main({
-                config: { toolFilter: 'router,proxysql,shell' },
-                databases: [{ type: 'mysql', host: 'localhost', database: 'test' } as any],
-                oauth: undefined
-            });
+      expect(mocks.adapterInstance.connect).not.toHaveBeenCalled();
+    });
 
-            expect(mocks.adapterInstance.connect).not.toHaveBeenCalled();
-        });
+    it("should skip MySQL connection for shell-only filter", async () => {
+      await main({
+        config: { toolFilter: "shell" },
+        databases: [
+          { type: "mysql", host: "localhost", database: "test" } as any,
+        ],
+        oauth: undefined,
+      });
 
-        it('should require MySQL connection for starter shortcut', async () => {
-            await main({
-                config: { toolFilter: 'starter' },
-                databases: [{ type: 'mysql', host: 'localhost', database: 'test' } as any],
-                oauth: undefined
-            });
+      expect(mocks.adapterInstance.connect).not.toHaveBeenCalled();
+    });
 
-            expect(mocks.adapterInstance.connect).toHaveBeenCalled();
-        });
+    it("should require MySQL connection for ecosystem shortcut (cluster needs MySQL)", async () => {
+      await main({
+        config: { toolFilter: "ecosystem" },
+        databases: [
+          { type: "mysql", host: "localhost", database: "test" } as any,
+        ],
+        oauth: undefined,
+      });
+
+      // ecosystem now includes cluster group which requires MySQL connection
+      expect(mocks.adapterInstance.connect).toHaveBeenCalled();
+    });
 
-        it('should require MySQL connection for dev-power shortcut', async () => {
-            await main({
-                config: { toolFilter: 'dev-power' },
-                databases: [{ type: 'mysql', host: 'localhost', database: 'test' } as any],
-                oauth: undefined
-            });
+    it("should skip MySQL connection for combined MySQL-optional groups", async () => {
+      await main({
+        config: { toolFilter: "router,proxysql,shell" },
+        databases: [
+          { type: "mysql", host: "localhost", database: "test" } as any,
+        ],
+        oauth: undefined,
+      });
 
-            expect(mocks.adapterInstance.connect).toHaveBeenCalled();
-        });
-
-        it('should require MySQL connection for mixed MySQL and non-MySQL groups', async () => {
-            await main({
-                config: { toolFilter: 'router,core' },
-                databases: [{ type: 'mysql', host: 'localhost', database: 'test' } as any],
-                oauth: undefined
-            });
+      expect(mocks.adapterInstance.connect).not.toHaveBeenCalled();
+    });
 
-            expect(mocks.adapterInstance.connect).toHaveBeenCalled();
-        });
+    it("should require MySQL connection for starter shortcut", async () => {
+      await main({
+        config: { toolFilter: "starter" },
+        databases: [
+          { type: "mysql", host: "localhost", database: "test" } as any,
+        ],
+        oauth: undefined,
+      });
 
-        it('should require MySQL connection for exclusion-only filters', async () => {
-            await main({
-                config: { toolFilter: '-router' },
-                databases: [{ type: 'mysql', host: 'localhost', database: 'test' } as any],
-                oauth: undefined
-            });
+      expect(mocks.adapterInstance.connect).toHaveBeenCalled();
+    });
 
-            // Exclusion only means no explicit enabled groups, so can't skip
-            expect(mocks.adapterInstance.connect).toHaveBeenCalled();
-        });
+    it("should require MySQL connection for dev-power shortcut", async () => {
+      await main({
+        config: { toolFilter: "dev-power" },
+        databases: [
+          { type: "mysql", host: "localhost", database: "test" } as any,
+        ],
+        oauth: undefined,
+      });
 
-        it('should create placeholder adapter when no databases but using external-only tools', async () => {
-            await main({
-                config: { toolFilter: 'router' },
-                databases: [],
-                oauth: undefined
-            });
-
-            // Should register a placeholder adapter
-            expect(mocks.serverInstance.registerAdapter).toHaveBeenCalledWith(
-                expect.anything(),
-                'mysql:external'
-            );
-        });
+      expect(mocks.adapterInstance.connect).toHaveBeenCalled();
+    });
 
-        it('should require MySQL connection for base-core shortcut', async () => {
-            await main({
-                config: { toolFilter: 'base-core' },
-                databases: [{ type: 'mysql', host: 'localhost', database: 'test' } as any],
-                oauth: undefined
-            });
+    it("should require MySQL connection for mixed MySQL and non-MySQL groups", async () => {
+      await main({
+        config: { toolFilter: "router,core" },
+        databases: [
+          { type: "mysql", host: "localhost", database: "test" } as any,
+        ],
+        oauth: undefined,
+      });
 
-            expect(mocks.adapterInstance.connect).toHaveBeenCalled();
-        });
+      expect(mocks.adapterInstance.connect).toHaveBeenCalled();
+    });
 
-        it('should require MySQL connection for ai-data shortcut', async () => {
-            await main({
-                config: { toolFilter: 'ai-data' },
-                databases: [{ type: 'mysql', host: 'localhost', database: 'test' } as any],
-                oauth: undefined
-            });
+    it("should require MySQL connection for exclusion-only filters", async () => {
+      await main({
+        config: { toolFilter: "-router" },
+        databases: [
+          { type: "mysql", host: "localhost", database: "test" } as any,
+        ],
+        oauth: undefined,
+      });
+
+      // Exclusion only means no explicit enabled groups, so can't skip
+      expect(mocks.adapterInstance.connect).toHaveBeenCalled();
+    });
 
-            expect(mocks.adapterInstance.connect).toHaveBeenCalled();
-        });
+    it("should create placeholder adapter when no databases but using external-only tools", async () => {
+      await main({
+        config: { toolFilter: "router" },
+        databases: [],
+        oauth: undefined,
+      });
+
+      // Should register a placeholder adapter
+      expect(mocks.serverInstance.registerAdapter).toHaveBeenCalledWith(
+        expect.anything(),
+        "mysql:external",
+      );
+    });
 
-        it('should require MySQL connection with no toolFilter', async () => {
-            await main({
-                config: {},
-                databases: [{ type: 'mysql', host: 'localhost', database: 'test' } as any],
-                oauth: undefined
-            });
+    it("should require MySQL connection for base-core shortcut", async () => {
+      await main({
+        config: { toolFilter: "base-core" },
+        databases: [
+          { type: "mysql", host: "localhost", database: "test" } as any,
+        ],
+        oauth: undefined,
+      });
 
-            expect(mocks.adapterInstance.connect).toHaveBeenCalled();
-        });
+      expect(mocks.adapterInstance.connect).toHaveBeenCalled();
     });
 
-    describe('main', () => {
-        it('should fail if no database config provided', async () => {
-            await expect(main({
-                config: {},
-                databases: [],
-                oauth: undefined
-            })).rejects.toThrow('process.exit(1)');
+    it("should require MySQL connection for ai-data shortcut", async () => {
+      await main({
+        config: { toolFilter: "ai-data" },
+        databases: [
+          { type: "mysql", host: "localhost", database: "test" } as any,
+        ],
+        oauth: undefined,
+      });
 
-            expect(mockConsoleError).toHaveBeenCalledWith(expect.stringContaining('No database connection specified'));
-        });
+      expect(mocks.adapterInstance.connect).toHaveBeenCalled();
+    });
 
-        it('should start server with valid config', async () => {
-            await main({
-                config: {},
-                databases: [{ type: 'mysql', host: 'localhost', database: 'test' } as any],
-                oauth: undefined
-            });
-
-            expect(mocks.createServer).toHaveBeenCalled();
-            expect(mocks.MySQLAdapter).toHaveBeenCalled(); // verify class instantiation
-            expect(mocks.adapterInstance.connect).toHaveBeenCalled();
-            expect(mocks.serverInstance.registerAdapter).toHaveBeenCalled();
-            expect(mocks.serverInstance.start).toHaveBeenCalled();
-        });
+    it("should require MySQL connection with no toolFilter", async () => {
+      await main({
+        config: {},
+        databases: [
+          { type: "mysql", host: "localhost", database: "test" } as any,
+        ],
+        oauth: undefined,
+      });
 
-        it('should handle startup error', async () => {
-            mocks.serverInstance.start.mockRejectedValue(new Error('Startup failed'));
+      expect(mocks.adapterInstance.connect).toHaveBeenCalled();
+    });
+  });
+
+  describe("main", () => {
+    it("should fail if no database config provided", async () => {
+      await expect(
+        main({
+          config: {},
+          databases: [],
+          oauth: undefined,
+        }),
+      ).rejects.toThrow("process.exit(1)");
+
+      expect(mockConsoleError).toHaveBeenCalledWith(
+        expect.stringContaining("No database connection specified"),
+      );
+    });
 
-            await expect(main({
-                config: {},
-                databases: [{ type: 'mysql', host: 'localhost', database: 'test' } as any],
-                oauth: undefined
-            })).rejects.toThrow('process.exit(1)');
+    it("should start server with valid config", async () => {
+      await main({
+        config: {},
+        databases: [
+          { type: "mysql", host: "localhost", database: "test" } as any,
+        ],
+        oauth: undefined,
+      });
+
+      expect(mocks.createServer).toHaveBeenCalled();
+      expect(mocks.MySQLAdapter).toHaveBeenCalled(); // verify class instantiation
+      expect(mocks.adapterInstance.connect).toHaveBeenCalled();
+      expect(mocks.serverInstance.registerAdapter).toHaveBeenCalled();
+      expect(mocks.serverInstance.start).toHaveBeenCalled();
+    });
 
-            expect(mockConsoleError).toHaveBeenCalledWith('Fatal error:', expect.any(Error));
-        });
+    it("should handle startup error", async () => {
+      mocks.serverInstance.start.mockRejectedValue(new Error("Startup failed"));
+
+      await expect(
+        main({
+          config: {},
+          databases: [
+            { type: "mysql", host: "localhost", database: "test" } as any,
+          ],
+          oauth: undefined,
+        }),
+      ).rejects.toThrow("process.exit(1)");
+
+      expect(mockConsoleError).toHaveBeenCalledWith(
+        "Fatal error:",
+        expect.any(Error),
+      );
+    });
 
-        it('should log oauth configuration if enabled', async () => {
-            await main({
-                config: {},
-                databases: [{ type: 'mysql', host: 'localhost', database: 'test' } as any],
-                oauth: {
-                    enabled: true,
-                    issuer: 'https://issuer.com',
-                    audience: 'aud'
-                }
-            });
-
-            expect(mockConsoleError).toHaveBeenCalledWith('OAuth authentication enabled');
-        });
+    it("should log oauth configuration if enabled", async () => {
+      await main({
+        config: {},
+        databases: [
+          { type: "mysql", host: "localhost", database: "test" } as any,
+        ],
+        oauth: {
+          enabled: true,
+          issuer: "https://issuer.com",
+          audience: "aud",
+        },
+      });
+
+      expect(mockConsoleError).toHaveBeenCalledWith(
+        "OAuth authentication enabled",
+      );
+    });
 
+    it("should exit immediately if shouldExit is true", async () => {
+      await expect(
+        main({
+          config: {},
+          databases: [],
+          oauth: undefined,
+          shouldExit: true,
+        }),
+      ).rejects.toThrow("process.exit(0)");
+    });
 
-        it('should exit immediately if shouldExit is true', async () => {
-            await expect(main({
-                config: {},
-                databases: [],
-                oauth: undefined,
-                shouldExit: true
-            })).rejects.toThrow('process.exit(0)');
+    it("should handle graceful shutdown on signal", async () => {
+      // Override mockExit to NOT throw for this test to avoid unhandled rejections from async void handler
+      mockExit.mockImplementation(() => {
+        return undefined as never;
+      });
+
+      const handlers: Record<string, () => void> = {};
+      const originalOn = process.on.bind(process);
+
+      const onSpy = vi
+        .spyOn(process, "on")
+        .mockImplementation((event, listener) => {
+          if (event === "SIGINT" || event === "SIGTERM") {
+            handlers[event as string] = listener as () => void;
+            return process;
+          }
+          return originalOn(event, listener);
         });
 
-        it('should handle graceful shutdown on signal', async () => {
-            // Override mockExit to NOT throw for this test to avoid unhandled rejections from async void handler
-            mockExit.mockImplementation(() => { return undefined as never });
-
-            const handlers: Record<string, () => void> = {};
-            const originalOn = process.on.bind(process);
-
-            const onSpy = vi.spyOn(process, 'on').mockImplementation((event, listener) => {
-                if (event === 'SIGINT' || event === 'SIGTERM') {
-                    handlers[event as string] = listener as () => void;
-                    return process;
-                }
-                return originalOn(event, listener);
-            });
+      await main({
+        config: {},
+        databases: [
+          { type: "mysql", host: "localhost", database: "test" } as any,
+        ],
+        oauth: undefined,
+      });
 
-            await main({
-                config: {},
-                databases: [{ type: 'mysql', host: 'localhost', database: 'test' } as any],
-                oauth: undefined
-            });
+      expect(handlers["SIGINT"]).toBeDefined();
+      expect(handlers["SIGTERM"]).toBeDefined();
 
-            expect(handlers['SIGINT']).toBeDefined();
-            expect(handlers['SIGTERM']).toBeDefined();
+      // Trigger shutdown (SIGINT)
+      handlers["SIGINT"]();
 
-            // Trigger shutdown (SIGINT)
-            handlers['SIGINT']();
+      // Wait for async execution
+      await new Promise((resolve) => setTimeout(resolve, 10));
 
-            // Wait for async execution
-            await new Promise(resolve => setTimeout(resolve, 10));
+      expect(mocks.serverInstance.stop).toHaveBeenCalled();
+      expect(mockConsoleError).toHaveBeenCalledWith(
+        expect.stringContaining("Shutting down"),
+      );
+      expect(mockExit).toHaveBeenCalledWith(0);
 
-            expect(mocks.serverInstance.stop).toHaveBeenCalled();
-            expect(mockConsoleError).toHaveBeenCalledWith(expect.stringContaining('Shutting down'));
-            expect(mockExit).toHaveBeenCalledWith(0);
-
-            onSpy.mockRestore();
-        });
+      onSpy.mockRestore();
     });
+  });
 });

package/src/__tests__/index.test.ts

@@ -1,25 +1,25 @@
-import { describe, it, expect } from 'vitest';
-import * as Index from '../index.js';
+import { describe, it, expect } from "vitest";
+import * as Index from "../index.js";
 
-describe('Index Exports', () => {
-    it('should export core modules', () => {
-        expect(Index.McpServer).toBeDefined();
-        expect(Index.DatabaseAdapter).toBeDefined();
-        expect(Index.MySQLAdapter).toBeDefined();
-        expect(Index.ConnectionPool).toBeDefined();
-    });
+describe("Index Exports", () => {
+  it("should export core modules", () => {
+    expect(Index.McpServer).toBeDefined();
+    expect(Index.DatabaseAdapter).toBeDefined();
+    expect(Index.MySQLAdapter).toBeDefined();
+    expect(Index.ConnectionPool).toBeDefined();
+  });
 
-    it('should export error classes', () => {
-        expect(Index.MySQLMcpError).toBeDefined();
-        expect(Index.ConnectionError).toBeDefined();
-        expect(Index.AuthenticationError).toBeDefined();
-    });
+  it("should export error classes", () => {
+    expect(Index.MySQLMcpError).toBeDefined();
+    expect(Index.ConnectionError).toBeDefined();
+    expect(Index.AuthenticationError).toBeDefined();
+  });
 
-    it('should export types', () => {
-        // Types are erased at runtime, but we can check if the module object has keys
-        // or just rely on the test compiling as verification that types are exported
-        // if we import them as types.
-        // For runtime check, we just verify the module object is substantial
-        expect(Object.keys(Index).length).toBeGreaterThan(0);
-    });
+  it("should export types", () => {
+    // Types are erased at runtime, but we can check if the module object has keys
+    // or just rely on the test compiling as verification that types are exported
+    // if we import them as types.
+    // For runtime check, we just verify the module object is substantial
+    expect(Object.keys(Index).length).toBeGreaterThan(0);
+  });
 });