@neverinfamous/mysql-mcp 2.1.0 → 2.3.0

package/src/__tests__/performance.test.ts

@@ -5,177 +5,186 @@
  * Run with: npm test -- --grep="Performance Benchmarks"
  */
 
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-import { SchemaManager } from '../adapters/mysql/SchemaManager.js';
-
-describe('Performance Benchmarks', () => {
-    describe('Tool Definition Caching', () => {
-        it('should return cached tool definitions on second call', () => {
-            // Simulate the caching behavior
-            let callCount = 0;
-            const generateTools = () => {
-                callCount++;
-                return Array.from({ length: 191 }, (_, i) => ({
-                    name: `tool_${String(i)}`,
-                    description: `Tool ${String(i)} description`,
-                }));
-            };
-
-            let cachedTools: ReturnType<typeof generateTools> | null = null;
-            const getToolDefinitions = () => {
-                if (cachedTools) return cachedTools;
-                cachedTools = generateTools();
-                return cachedTools;
-            };
-
-            // First call - should generate
-            const startFirst = performance.now();
-            const tools1 = getToolDefinitions();
-            const firstDuration = performance.now() - startFirst;
-
-            // Second call - should use cache
-            const startSecond = performance.now();
-            const tools2 = getToolDefinitions();
-            const secondDuration = performance.now() - startSecond;
-
-            expect(tools1).toBe(tools2); // Same reference
-            expect(callCount).toBe(1); // Only generated once
-            expect(secondDuration).toBeLessThan(firstDuration); // Cache is faster
-        });
-
-        it('should generate 191 tool definitions', () => {
-            // Verify the tool count matches documentation
-            const toolGroups = {
-                core: 8,
-                transactions: 7,
-                json: 17,
-                text: 6,
-                fulltext: 4,
-                performance: 8,
-                optimization: 4,
-                admin: 6,
-                monitoring: 7,
-                backup: 4,
-                replication: 5,
-                partitioning: 4,
-                router: 9,
-                proxysql: 12,
-                shell: 10,
-                schema: 10,
-                events: 6,
-                sysschema: 8,
-                stats: 8,
-                spatial: 12,
-                security: 9,
-                cluster: 10,
-                roles: 8,
-                docstore: 9,
-            };
-
-            const total = Object.values(toolGroups).reduce((a, b) => a + b, 0);
-            expect(total).toBe(191);
-        });
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import { SchemaManager } from "../adapters/mysql/SchemaManager.js";
+
+describe("Performance Benchmarks", () => {
+  describe("Tool Definition Caching", () => {
+    it("should return cached tool definitions on second call", () => {
+      // Simulate the caching behavior
+      let callCount = 0;
+      const generateTools = () => {
+        callCount++;
+        return Array.from({ length: 192 }, (_, i) => ({
+          name: `tool_${String(i)}`,
+          description: `Tool ${String(i)} description`,
+        }));
+      };
+
+      let cachedTools: ReturnType<typeof generateTools> | null = null;
+      const getToolDefinitions = () => {
+        if (cachedTools) return cachedTools;
+        cachedTools = generateTools();
+        return cachedTools;
+      };
+
+      // First call - should generate
+      const startFirst = performance.now();
+      const tools1 = getToolDefinitions();
+      const firstDuration = performance.now() - startFirst;
+
+      // Second call - should use cache
+      const startSecond = performance.now();
+      const tools2 = getToolDefinitions();
+      const secondDuration = performance.now() - startSecond;
+
+      expect(tools1).toBe(tools2); // Same reference
+      expect(callCount).toBe(1); // Only generated once
+      expect(secondDuration).toBeLessThan(firstDuration); // Cache is faster
     });
 
-    describe('Metadata Cache TTL', () => {
-        beforeEach(() => {
-            vi.useFakeTimers();
-        });
-
-        afterEach(() => {
-            vi.useRealTimers();
-        });
-
-        it('should return cached value before TTL expires', () => {
-            const cache = new Map<string, { data: unknown; timestamp: number }>();
-            const TTL_MS = 30000;
-
-            // Set cache
-            cache.set('test_key', { data: { value: 'cached' }, timestamp: Date.now() });
-
-            // Advance time less than TTL
-            vi.advanceTimersByTime(15000);
-
-            // Check cache
-            const entry = cache.get('test_key');
-            expect(entry).toBeDefined();
-            const isExpired = Date.now() - entry!.timestamp > TTL_MS;
-            expect(isExpired).toBe(false);
-        });
-
-        it('should expire cached value after TTL', () => {
-            const cache = new Map<string, { data: unknown; timestamp: number }>();
-            const TTL_MS = 30000;
-
-            // Set cache
-            cache.set('test_key', { data: { value: 'cached' }, timestamp: Date.now() });
-
-            // Advance time past TTL
-            vi.advanceTimersByTime(31000);
-
-            // Check cache
-            const entry = cache.get('test_key');
-            expect(entry).toBeDefined();
-            const isExpired = Date.now() - entry!.timestamp > TTL_MS;
-            expect(isExpired).toBe(true);
-        });
-
-        it('should use configurable TTL from environment', () => {
-            const defaultTtl = parseInt(process.env['METADATA_CACHE_TTL_MS'] ?? '30000', 10);
-            expect(defaultTtl).toBe(30000);
-        });
+    it("should generate 191 tool definitions", () => {
+      // Verify the tool count matches documentation
+      const toolGroups = {
+        core: 8,
+        transactions: 7,
+        json: 17,
+        text: 6,
+        fulltext: 5,
+        performance: 8,
+        optimization: 4,
+        admin: 6,
+        monitoring: 7,
+        backup: 4,
+        replication: 5,
+        partitioning: 4,
+        router: 9,
+        proxysql: 12,
+        shell: 10,
+        schema: 10,
+        events: 6,
+        sysschema: 8,
+        stats: 8,
+        spatial: 12,
+        security: 9,
+        cluster: 10,
+        roles: 8,
+        docstore: 9,
+      };
+
+      const total = Object.values(toolGroups).reduce((a, b) => a + b, 0);
+      expect(total).toBe(192);
     });
+  });
 
-    describe('Parallel Query Execution', () => {
-        it('should demonstrate parallel execution concept', () => {
-            // This test verifies the conceptual benefit of parallel execution
-            // Real query timing depends on database latency, so we verify the pattern
-
-            // Sequential pattern: wait for each before next
-            const sequentialPattern = (queries: number) => {
-                // Total time = sum of all query times
-                return queries * 1; // 1 unit per query
-            };
-
-            // Parallel pattern: all at once
-            const parallelPattern = (_queries: number) => {
-                // Total time = max of all query times (all roughly equal)
-                return 1; // 1 unit (concurrent)
-            };
-
-            const queryCount = 2; // health resource has 2 queries
-            const sequentialUnits = sequentialPattern(queryCount);
-            const parallelUnits = parallelPattern(queryCount);
-
-            // Parallel is faster (2x for 2 queries)
-            expect(parallelUnits).toBeLessThan(sequentialUnits);
-            expect(sequentialUnits / parallelUnits).toBe(2);
-        });
+  describe("Metadata Cache TTL", () => {
+    beforeEach(() => {
+      vi.useFakeTimers();
     });
 
-    describe('Batch Query Pattern', () => {
-        it('should use single query instead of N+1 for indexes', () => {
-            // Verify the optimization concept: single query vs N+1
-            const tableCount = 100;
-            const singleQueryCount = 1; // Batch query
-            const nPlusOneQueryCount = tableCount + 1; // N+1 pattern
-
-            // Expected improvement: N+1 → 1 query (reduced by tableCount)
-            const improvement = nPlusOneQueryCount / singleQueryCount;
-            expect(improvement).toBe(101); // For 100 tables, 101x fewer queries
-        });
+    afterEach(() => {
+      vi.useRealTimers();
     });
 
-    describe('SchemaManager Cache', () => {
-        it('should have clearCache method', () => {
-            const mockExecutor = {
-                executeQuery: vi.fn().mockResolvedValue({ rows: [] })
-            };
-            const schemaManager = new SchemaManager(mockExecutor);
-
-            // Verify clearCache method exists and is callable
-            expect(typeof schemaManager.clearCache).toBe('function');
-            schemaManager.clearCache(); // Should not throw
-        });
+    it("should return cached value before TTL expires", () => {
+      const cache = new Map<string, { data: unknown; timestamp: number }>();
+      const TTL_MS = 30000;
+
+      // Set cache
+      cache.set("test_key", {
+        data: { value: "cached" },
+        timestamp: Date.now(),
+      });
+
+      // Advance time less than TTL
+      vi.advanceTimersByTime(15000);
+
+      // Check cache
+      const entry = cache.get("test_key");
+      expect(entry).toBeDefined();
+      const isExpired = Date.now() - entry!.timestamp > TTL_MS;
+      expect(isExpired).toBe(false);
+    });
+
+    it("should expire cached value after TTL", () => {
+      const cache = new Map<string, { data: unknown; timestamp: number }>();
+      const TTL_MS = 30000;
+
+      // Set cache
+      cache.set("test_key", {
+        data: { value: "cached" },
+        timestamp: Date.now(),
+      });
+
+      // Advance time past TTL
+      vi.advanceTimersByTime(31000);
+
+      // Check cache
+      const entry = cache.get("test_key");
+      expect(entry).toBeDefined();
+      const isExpired = Date.now() - entry!.timestamp > TTL_MS;
+      expect(isExpired).toBe(true);
+    });
+
+    it("should use configurable TTL from environment", () => {
+      const defaultTtl = parseInt(
+        process.env["METADATA_CACHE_TTL_MS"] ?? "30000",
+        10,
+      );
+      expect(defaultTtl).toBe(30000);
+    });
+  });
+
+  describe("Parallel Query Execution", () => {
+    it("should demonstrate parallel execution concept", () => {
+      // This test verifies the conceptual benefit of parallel execution
+      // Real query timing depends on database latency, so we verify the pattern
+
+      // Sequential pattern: wait for each before next
+      const sequentialPattern = (queries: number) => {
+        // Total time = sum of all query times
+        return queries * 1; // 1 unit per query
+      };
+
+      // Parallel pattern: all at once
+      const parallelPattern = (_queries: number) => {
+        // Total time = max of all query times (all roughly equal)
+        return 1; // 1 unit (concurrent)
+      };
+
+      const queryCount = 2; // health resource has 2 queries
+      const sequentialUnits = sequentialPattern(queryCount);
+      const parallelUnits = parallelPattern(queryCount);
+
+      // Parallel is faster (2x for 2 queries)
+      expect(parallelUnits).toBeLessThan(sequentialUnits);
+      expect(sequentialUnits / parallelUnits).toBe(2);
+    });
+  });
+
+  describe("Batch Query Pattern", () => {
+    it("should use single query instead of N+1 for indexes", () => {
+      // Verify the optimization concept: single query vs N+1
+      const tableCount = 100;
+      const singleQueryCount = 1; // Batch query
+      const nPlusOneQueryCount = tableCount + 1; // N+1 pattern
+
+      // Expected improvement: N+1 → 1 query (reduced by tableCount)
+      const improvement = nPlusOneQueryCount / singleQueryCount;
+      expect(improvement).toBe(101); // For 100 tables, 101x fewer queries
+    });
+  });
+
+  describe("SchemaManager Cache", () => {
+    it("should have clearCache method", () => {
+      const mockExecutor = {
+        executeQuery: vi.fn().mockResolvedValue({ rows: [] }),
+      };
+      const schemaManager = new SchemaManager(mockExecutor);
+
+      // Verify clearCache method exists and is callable
+      expect(typeof schemaManager.clearCache).toBe("function");
+      schemaManager.clearCache(); // Should not throw
     });
+  });
 });

package/src/__tests__/setup.ts

@@ -1,10 +1,10 @@
 /**
  * mysql-mcp - Global Test Setup
- * 
+ *
  * Common test utilities and setup for all test files.
  */
 
-import { vi } from 'vitest';
+import { vi } from "vitest";
 
 // Mock console to reduce noise in tests (optional - can be removed for debugging)
 // vi.spyOn(console, 'log').mockImplementation(() => {});
@@ -15,7 +15,7 @@ import { vi } from 'vitest';
  * Reset all mocks after each test
  */
 export function setupTestEnvironment(): void {
-    vi.clearAllMocks();
+  vi.clearAllMocks();
 }
 
 /**
@@ -23,33 +23,38 @@ export function setupTestEnvironment(): void {
  * Uses the Docker MySQL container when available
  */
 export const TEST_DB_CONFIG = {
-    host: 'localhost',
-    port: 3306,
-    user: 'root',
-    password: 'root',
-    database: 'testdb'
+  host: "localhost",
+  port: 3306,
+  user: "root",
+  password: "root",
+  database: "testdb",
 };
 
 /**
  * Helper to create a mock query result
  */
-export function createMockQueryResult<T>(rows: T[], affectedRows = 0): {
-    rows: T[];
-    fields: Array<{ name: string; type: number }>;
-    affectedRows: number;
-    insertId: number;
+export function createMockQueryResult<T>(
+  rows: T[],
+  affectedRows = 0,
+): {
+  rows: T[];
+  fields: Array<{ name: string; type: number }>;
+  affectedRows: number;
+  insertId: number;
 } {
-    return {
-        rows,
-        fields: [],
-        affectedRows,
-        insertId: 0
-    };
+  return {
+    rows,
+    fields: [],
+    affectedRows,
+    insertId: 0,
+  };
 }
 
 /**
  * Helper to create mock field metadata
  */
-export function createMockFields(names: string[]): Array<{ name: string; type: number }> {
-    return names.map(name => ({ name, type: 253 })); // 253 = VARCHAR
+export function createMockFields(
+  names: string[],
+): Array<{ name: string; type: number }> {
+  return names.map((name) => ({ name, type: 253 })); // 253 = VARCHAR
 }