@neverinfamous/mysql-mcp 2.1.0 → 2.2.0

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

@@ -1,110 +1,148 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { createMockMySQLAdapter, createMockQueryResult, createMockRequestContext } from '../../../../__tests__/mocks/index.js';
-import type { MySQLAdapter } from '../../MySQLAdapter.js';
-import { createLocksResource } from '../locks.js';
-
-describe('Locks Resource', () => {
-    let mockAdapter: ReturnType<typeof createMockMySQLAdapter>;
-    let mockContext: ReturnType<typeof createMockRequestContext>;
-
-    beforeEach(() => {
-        vi.clearAllMocks();
-        mockAdapter = createMockMySQLAdapter();
-        mockContext = createMockRequestContext();
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import {
+  createMockMySQLAdapter,
+  createMockQueryResult,
+  createMockRequestContext,
+} from "../../../../__tests__/mocks/index.js";
+import type { MySQLAdapter } from "../../MySQLAdapter.js";
+import { createLocksResource } from "../locks.js";
+
+describe("Locks Resource", () => {
+  let mockAdapter: ReturnType<typeof createMockMySQLAdapter>;
+  let mockContext: ReturnType<typeof createMockRequestContext>;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mockAdapter = createMockMySQLAdapter();
+    mockContext = createMockRequestContext();
+  });
+
+  it("should return lock information including waits and statistics", async () => {
+    // Mock data_lock_waits query
+    mockAdapter.executeQuery.mockResolvedValueOnce(
+      createMockQueryResult([
+        {
+          waiting_trx_id: "100",
+          waiting_thread: 1,
+          waiting_query: "SELECT * FROM users FOR UPDATE",
+          blocking_trx_id: "101",
+          blocking_thread: 2,
+          blocking_query: 'UPDATE users SET name = "test"',
+          wait_seconds: 5,
+        },
+      ]),
+    );
+
+    // Mock Innodb_row_lock% status query
+    mockAdapter.executeQuery.mockResolvedValueOnce(
+      createMockQueryResult([
+        { Variable_name: "Innodb_row_lock_current_waits", Value: "1" },
+        { Variable_name: "Innodb_row_lock_time", Value: "5000" },
+      ]),
+    );
+
+    const resource = createLocksResource(
+      mockAdapter as unknown as MySQLAdapter,
+    );
+    const result = (await resource.handler(
+      "mysql://locks",
+      mockContext,
+    )) as any;
+
+    expect(result.currentLockWaits).toBe(1);
+    expect(result.lockWaits).toHaveLength(1);
+    expect(result.lockWaits[0]).toHaveProperty("waiting_trx_id", "100");
+    expect(result.lockStatistics).toHaveProperty(
+      "Innodb_row_lock_current_waits",
+      "1",
+    );
+  });
+
+  it("should handle errors gracefully", async () => {
+    mockAdapter.executeQuery.mockRejectedValue(new Error("Database error"));
+
+    const resource = createLocksResource(
+      mockAdapter as unknown as MySQLAdapter,
+    );
+    const result = (await resource.handler(
+      "mysql://locks",
+      mockContext,
+    )) as any;
+
+    expect(result).toHaveProperty("error");
+    expect(result.currentLockWaits).toBe(0);
+    expect(result.lockWaits).toHaveLength(0);
+  });
+
+  it("should handle empty lock stats", async () => {
+    // Mock data_lock_waits query
+    mockAdapter.executeQuery.mockResolvedValueOnce(createMockQueryResult([]));
+
+    // Mock Innodb_row_lock% status query returning empty or malformed
+    mockAdapter.executeQuery.mockResolvedValueOnce(createMockQueryResult([]));
+
+    const resource = createLocksResource(
+      mockAdapter as unknown as MySQLAdapter,
+    );
+    const result = (await resource.handler(
+      "mysql://locks",
+      mockContext,
+    )) as any;
+
+    expect(result.currentLockWaits).toBe(0);
+    expect(result.lockStatistics).toEqual({});
+  });
+
+  it("should handle non-string variable names gracefully", async () => {
+    // Mock data_lock_waits query
+    mockAdapter.executeQuery.mockResolvedValueOnce(createMockQueryResult([]));
+
+    // Mock Innodb_row_lock% status query with non-string name
+    mockAdapter.executeQuery.mockResolvedValueOnce(
+      createMockQueryResult([
+        { Variable_name: null, Value: "123" },
+        { Variable_name: 123, Value: "456" },
+        { Variable_name: "valid_var", Value: "789" },
+      ]),
+    );
+
+    const resource = createLocksResource(
+      mockAdapter as unknown as MySQLAdapter,
+    );
+    const result = (await resource.handler(
+      "mysql://locks",
+      mockContext,
+    )) as any;
+
+    expect(result.lockStatistics).toEqual({
+      valid_var: "789",
     });
-
-    it('should return lock information including waits and statistics', async () => {
-        // Mock data_lock_waits query
-        mockAdapter.executeQuery.mockResolvedValueOnce(createMockQueryResult([
-            {
-                waiting_trx_id: '100',
-                waiting_thread: 1,
-                waiting_query: 'SELECT * FROM users FOR UPDATE',
-                blocking_trx_id: '101',
-                blocking_thread: 2,
-                blocking_query: 'UPDATE users SET name = "test"',
-                wait_seconds: 5
-            }
-        ]));
-
-        // Mock Innodb_row_lock% status query
-        mockAdapter.executeQuery.mockResolvedValueOnce(createMockQueryResult([
-            { Variable_name: 'Innodb_row_lock_current_waits', Value: '1' },
-            { Variable_name: 'Innodb_row_lock_time', Value: '5000' }
-        ]));
-
-        const resource = createLocksResource(mockAdapter as unknown as MySQLAdapter);
-        const result = await resource.handler('mysql://locks', mockContext) as any;
-
-        expect(result.currentLockWaits).toBe(1);
-        expect(result.lockWaits).toHaveLength(1);
-        expect(result.lockWaits[0]).toHaveProperty('waiting_trx_id', '100');
-        expect(result.lockStatistics).toHaveProperty('Innodb_row_lock_current_waits', '1');
+  });
+  it("should handle undefined rows from query results gracefully", async () => {
+    // Mock data_lock_waits query returning valid result object but with undefined rows
+    mockAdapter.executeQuery.mockResolvedValueOnce({
+      rows: undefined,
+      rowsAffected: 0,
+      executionTimeMs: 0,
     });
 
-    it('should handle errors gracefully', async () => {
-        mockAdapter.executeQuery.mockRejectedValue(new Error('Database error'));
-
-        const resource = createLocksResource(mockAdapter as unknown as MySQLAdapter);
-        const result = await resource.handler('mysql://locks', mockContext) as any;
-
-        expect(result).toHaveProperty('error');
-        expect(result.currentLockWaits).toBe(0);
-        expect(result.lockWaits).toHaveLength(0);
+    // Mock Innodb_row_lock% status query returning valid result but undefined rows
+    mockAdapter.executeQuery.mockResolvedValueOnce({
+      rows: undefined,
+      rowsAffected: 0,
+      executionTimeMs: 0,
     });
 
-    it('should handle empty lock stats', async () => {
-        // Mock data_lock_waits query
-        mockAdapter.executeQuery.mockResolvedValueOnce(createMockQueryResult([]));
-
-        // Mock Innodb_row_lock% status query returning empty or malformed
-        mockAdapter.executeQuery.mockResolvedValueOnce(createMockQueryResult([]));
-
-        const resource = createLocksResource(mockAdapter as unknown as MySQLAdapter);
-        const result = await resource.handler('mysql://locks', mockContext) as any;
-
-        expect(result.currentLockWaits).toBe(0);
-        expect(result.lockStatistics).toEqual({});
-    });
-
-    it('should handle non-string variable names gracefully', async () => {
-        // Mock data_lock_waits query
-        mockAdapter.executeQuery.mockResolvedValueOnce(createMockQueryResult([]));
-
-        // Mock Innodb_row_lock% status query with non-string name
-        mockAdapter.executeQuery.mockResolvedValueOnce(createMockQueryResult([
-            { Variable_name: null, Value: '123' },
-            { Variable_name: 123, Value: '456' },
-            { Variable_name: 'valid_var', Value: '789' }
-        ]));
-
-        const resource = createLocksResource(mockAdapter as unknown as MySQLAdapter);
-        const result = await resource.handler('mysql://locks', mockContext) as any;
-
-        expect(result.lockStatistics).toEqual({
-            'valid_var': '789'
-        });
-    });
-    it('should handle undefined rows from query results gracefully', async () => {
-        // Mock data_lock_waits query returning valid result object but with undefined rows
-        mockAdapter.executeQuery.mockResolvedValueOnce({
-            rows: undefined,
-            rowsAffected: 0,
-            executionTimeMs: 0
-        });
-
-        // Mock Innodb_row_lock% status query returning valid result but undefined rows
-        mockAdapter.executeQuery.mockResolvedValueOnce({
-            rows: undefined,
-            rowsAffected: 0,
-            executionTimeMs: 0
-        });
-
-        const resource = createLocksResource(mockAdapter as unknown as MySQLAdapter);
-        const result = await resource.handler('mysql://locks', mockContext) as any;
-
-        expect(result.currentLockWaits).toBe(0);
-        expect(result.lockWaits).toEqual([]);
-        expect(result.lockStatistics).toEqual({});
-    });
+    const resource = createLocksResource(
+      mockAdapter as unknown as MySQLAdapter,
+    );
+    const result = (await resource.handler(
+      "mysql://locks",
+      mockContext,
+    )) as any;
+
+    expect(result.currentLockWaits).toBe(0);
+    expect(result.lockWaits).toEqual([]);
+    expect(result.lockStatistics).toEqual({});
+  });
 });

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

@@ -1,60 +1,83 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { createPerformanceResource } from "../performance.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 { createPerformanceResource } from '../performance.js';
-import type { MySQLAdapter } from '../../MySQLAdapter.js';
-import { createMockMySQLAdapter, createMockRequestContext, createMockQueryResult } from '../../../../__tests__/mocks/index.js';
-
-describe('Performance Resource', () => {
-    let mockAdapter: ReturnType<typeof createMockMySQLAdapter>;
-    let mockContext: ReturnType<typeof createMockRequestContext>;
-
-    beforeEach(() => {
-        vi.clearAllMocks();
-        mockAdapter = createMockMySQLAdapter();
-        mockContext = createMockRequestContext();
-    });
-
-    it('should return performance metrics', async () => {
-        // Mock status
-        mockAdapter.executeQuery.mockResolvedValueOnce(createMockQueryResult([
-            { Variable_name: 'Queries', Value: '100000' },
-            { Variable_name: 'Slow_queries', Value: '50' },
-            { Variable_name: 'Select_full_join', Value: '10' },
-            { Variable_name: 'Created_tmp_tables', Value: '1000' },
-            { Variable_name: 'Created_tmp_disk_tables', Value: '100' },
-            { Variable_name: 'Handler_read_key', Value: '50000' },
-            { Variable_name: 'Handler_read_rnd_next', Value: '10000' }
-        ]));
-        // Mock performance schema query
-        mockAdapter.executeQuery.mockResolvedValueOnce(createMockQueryResult([
-            { query_pattern: 'SELECT * FROM users', execution_count: 100, total_time_ms: 500 }
-        ]));
-
-        const resource = createPerformanceResource(mockAdapter as unknown as MySQLAdapter);
-        const result = await resource.handler('mysql://performance', mockContext) as { summary: { total_queries: number } };
-
-        expect(result).toHaveProperty('summary');
-        expect(result.summary).toHaveProperty('total_queries', 100000);
-        expect(result.summary).toHaveProperty('slow_queries', 50);
-        expect(result).toHaveProperty('sorts');
-        expect(result).toHaveProperty('joins');
-        expect(result).toHaveProperty('handler');
-        expect(result).toHaveProperty('top_queries');
-    });
-
-    it('should handle missing performance schema', async () => {
-        // Mock status success
-        mockAdapter.executeQuery.mockResolvedValueOnce(createMockQueryResult([
-            { Variable_name: 'Queries', Value: '500' }
-        ]));
-
-        // Mock performance schema failure
-        mockAdapter.executeQuery.mockRejectedValueOnce(new Error('Table doesn\'t exist'));
-
-        const resource = createPerformanceResource(mockAdapter as unknown as MySQLAdapter);
-        const result = await resource.handler('mysql://performance', mockContext) as { summary: object, top_queries: unknown[] };
-
-        expect(result.top_queries).toEqual([]);
-        expect(result.summary).toHaveProperty('total_queries', 500);
-    });
+describe("Performance Resource", () => {
+  let mockAdapter: ReturnType<typeof createMockMySQLAdapter>;
+  let mockContext: ReturnType<typeof createMockRequestContext>;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mockAdapter = createMockMySQLAdapter();
+    mockContext = createMockRequestContext();
+  });
+
+  it("should return performance metrics", async () => {
+    // Mock status
+    mockAdapter.executeQuery.mockResolvedValueOnce(
+      createMockQueryResult([
+        { Variable_name: "Queries", Value: "100000" },
+        { Variable_name: "Slow_queries", Value: "50" },
+        { Variable_name: "Select_full_join", Value: "10" },
+        { Variable_name: "Created_tmp_tables", Value: "1000" },
+        { Variable_name: "Created_tmp_disk_tables", Value: "100" },
+        { Variable_name: "Handler_read_key", Value: "50000" },
+        { Variable_name: "Handler_read_rnd_next", Value: "10000" },
+      ]),
+    );
+    // Mock performance schema query
+    mockAdapter.executeQuery.mockResolvedValueOnce(
+      createMockQueryResult([
+        {
+          query_pattern: "SELECT * FROM users",
+          execution_count: 100,
+          total_time_ms: 500,
+        },
+      ]),
+    );
+
+    const resource = createPerformanceResource(
+      mockAdapter as unknown as MySQLAdapter,
+    );
+    const result = (await resource.handler(
+      "mysql://performance",
+      mockContext,
+    )) as { summary: { total_queries: number } };
+
+    expect(result).toHaveProperty("summary");
+    expect(result.summary).toHaveProperty("total_queries", 100000);
+    expect(result.summary).toHaveProperty("slow_queries", 50);
+    expect(result).toHaveProperty("sorts");
+    expect(result).toHaveProperty("joins");
+    expect(result).toHaveProperty("handler");
+    expect(result).toHaveProperty("top_queries");
+  });
+
+  it("should handle missing performance schema", async () => {
+    // Mock status success
+    mockAdapter.executeQuery.mockResolvedValueOnce(
+      createMockQueryResult([{ Variable_name: "Queries", Value: "500" }]),
+    );
+
+    // Mock performance schema failure
+    mockAdapter.executeQuery.mockRejectedValueOnce(
+      new Error("Table doesn't exist"),
+    );
+
+    const resource = createPerformanceResource(
+      mockAdapter as unknown as MySQLAdapter,
+    );
+    const result = (await resource.handler(
+      "mysql://performance",
+      mockContext,
+    )) as { summary: object; top_queries: unknown[] };
+
+    expect(result.top_queries).toEqual([]);
+    expect(result.summary).toHaveProperty("total_queries", 500);
+  });
 });

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

@@ -1,50 +1,55 @@
-
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { createPoolResource } from '../pool.js';
-import type { MySQLAdapter } from '../../MySQLAdapter.js';
-import { createMockMySQLAdapter, createMockRequestContext } from '../../../../__tests__/mocks/index.js';
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { createPoolResource } from "../pool.js";
+import type { MySQLAdapter } from "../../MySQLAdapter.js";
+import {
+  createMockMySQLAdapter,
+  createMockRequestContext,
+} from "../../../../__tests__/mocks/index.js";
 
 interface PoolResult {
-    poolStats?: { total: number; active: number; idle: number };
-    error?: string;
+  poolStats?: { total: number; active: number; idle: number };
+  error?: string;
 }
 
-describe('Pool Resource', () => {
-    let mockAdapter: ReturnType<typeof createMockMySQLAdapter>;
-    let mockContext: ReturnType<typeof createMockRequestContext>;
-
-    beforeEach(() => {
-        vi.clearAllMocks();
-        mockAdapter = createMockMySQLAdapter();
-        mockContext = createMockRequestContext();
+describe("Pool Resource", () => {
+  let mockAdapter: ReturnType<typeof createMockMySQLAdapter>;
+  let mockContext: ReturnType<typeof createMockRequestContext>;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mockAdapter = createMockMySQLAdapter();
+    mockContext = createMockRequestContext();
+  });
+
+  it("should return pool statistics when pool available", async () => {
+    (mockAdapter.getPool as ReturnType<typeof vi.fn>).mockReturnValue({
+      getStats: () => ({
+        total: 10,
+        active: 3,
+        idle: 7,
+        waiting: 0,
+        totalQueries: 500,
+      }),
     });
 
-    it('should return pool statistics when pool available', async () => {
-        (mockAdapter.getPool as ReturnType<typeof vi.fn>).mockReturnValue({
-            getStats: () => ({
-                total: 10,
-                active: 3,
-                idle: 7,
-                waiting: 0,
-                totalQueries: 500
-            })
-        });
-
-        const resource = createPoolResource(mockAdapter as unknown as MySQLAdapter);
-        const result = await resource.handler('mysql://pool', mockContext) as PoolResult;
-
-        expect(result).toHaveProperty('poolStats');
-        expect(result.poolStats).toHaveProperty('total', 10);
-        expect(result.poolStats).toHaveProperty('active', 3);
-        expect(result.poolStats).toHaveProperty('idle', 7);
-    });
+    const resource = createPoolResource(mockAdapter as unknown as MySQLAdapter);
+    const result = (await resource.handler(
+      "mysql://pool",
+      mockContext,
+    )) as PoolResult;
 
-    it('should handle missing pool gracefully', async () => {
-        (mockAdapter.getPool as ReturnType<typeof vi.fn>).mockReturnValue(null);
+    expect(result).toHaveProperty("poolStats");
+    expect(result.poolStats).toHaveProperty("total", 10);
+    expect(result.poolStats).toHaveProperty("active", 3);
+    expect(result.poolStats).toHaveProperty("idle", 7);
+  });
 
-        const resource = createPoolResource(mockAdapter as unknown as MySQLAdapter);
-        const result = await resource.handler('mysql://pool', mockContext);
+  it("should handle missing pool gracefully", async () => {
+    (mockAdapter.getPool as ReturnType<typeof vi.fn>).mockReturnValue(null);
 
-        expect(result).toHaveProperty('error');
-    });
+    const resource = createPoolResource(mockAdapter as unknown as MySQLAdapter);
+    const result = await resource.handler("mysql://pool", mockContext);
+
+    expect(result).toHaveProperty("error");
+  });
 });

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

@@ -1,29 +1,45 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { createProcesslistResource } from "../processlist.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 { createProcesslistResource } from '../processlist.js';
-import type { MySQLAdapter } from '../../MySQLAdapter.js';
-import { createMockMySQLAdapter, createMockRequestContext, createMockQueryResult } from '../../../../__tests__/mocks/index.js';
+describe("ProcessList Resource", () => {
+  let mockAdapter: ReturnType<typeof createMockMySQLAdapter>;
+  let mockContext: ReturnType<typeof createMockRequestContext>;
 
-describe('ProcessList 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 execute SHOW PROCESSLIST query", async () => {
+    mockAdapter.executeQuery.mockResolvedValue(
+      createMockQueryResult([
+        {
+          Id: 1,
+          User: "root",
+          Host: "localhost",
+          db: "test",
+          Command: "Query",
+          Time: 0,
+          State: "executing",
+          Info: "SELECT 1",
+        },
+      ]),
+    );
 
-    it('should execute SHOW PROCESSLIST query', async () => {
-        mockAdapter.executeQuery.mockResolvedValue(createMockQueryResult([
-            { Id: 1, User: 'root', Host: 'localhost', db: 'test', Command: 'Query', Time: 0, State: 'executing', Info: 'SELECT 1' }
-        ]));
+    const resource = createProcesslistResource(
+      mockAdapter as unknown as MySQLAdapter,
+    );
+    await resource.handler("mysql://processlist", mockContext);
 
-        const resource = createProcesslistResource(mockAdapter as unknown as MySQLAdapter);
-        await resource.handler('mysql://processlist', mockContext);
-
-        expect(mockAdapter.executeQuery).toHaveBeenCalledWith(
-            expect.stringContaining('PROCESSLIST')
-        );
-    });
+    expect(mockAdapter.executeQuery).toHaveBeenCalledWith(
+      expect.stringContaining("PROCESSLIST"),
+    );
+  });
 });