@neverinfamous/mysql-mcp 2.1.0 → 2.2.0

package/src/adapters/mysql/__tests__/SchemaManager.test.ts

@@ -1,165 +1,207 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import { SchemaManager, QueryExecutor } from "../SchemaManager.js";
+import { ValidationError } from "../../../types/index.js";
+
+describe("SchemaManager", () => {
+  let manager: SchemaManager;
+  let mockExecutor: QueryExecutor;
+
+  beforeEach(() => {
+    mockExecutor = {
+      executeQuery: vi.fn(),
+    };
+    manager = new SchemaManager(mockExecutor);
+  });
+
+  describe("cache functionality", () => {
+    beforeEach(() => {
+      vi.useFakeTimers();
+    });
+
+    afterEach(() => {
+      vi.useRealTimers();
+    });
 
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-import { SchemaManager, QueryExecutor } from '../SchemaManager.js';
-import { ValidationError } from '../../../types/index.js';
+    it("should cache getAllIndexes results", async () => {
+      (mockExecutor.executeQuery as ReturnType<typeof vi.fn>).mockResolvedValue(
+        { rows: [] },
+      );
+
+      // First call - should query database
+      await manager.getSchema();
+      expect(mockExecutor.executeQuery).toHaveBeenCalledTimes(2); // listTables + getAllIndexes
+
+      // Second call - should use cache for both listTables and getAllIndexes
+      (mockExecutor.executeQuery as ReturnType<typeof vi.fn>).mockClear();
+      (mockExecutor.executeQuery as ReturnType<typeof vi.fn>).mockResolvedValue(
+        { rows: [] },
+      );
+      await manager.getSchema();
+      // Both listTables and getAllIndexes are now cached
+      expect(mockExecutor.executeQuery).toHaveBeenCalledTimes(0);
+    });
 
-describe('SchemaManager', () => {
-    let manager: SchemaManager;
-    let mockExecutor: QueryExecutor;
+    it("should expire cache after TTL", async () => {
+      (mockExecutor.executeQuery as ReturnType<typeof vi.fn>).mockResolvedValue(
+        { rows: [] },
+      );
 
-    beforeEach(() => {
-        mockExecutor = {
-            executeQuery: vi.fn()
-        };
-        manager = new SchemaManager(mockExecutor);
+      // First call
+      await manager.getSchema();
+
+      // Advance time past TTL (31 seconds)
+      vi.advanceTimersByTime(31000);
+
+      // Clear the mock to count fresh calls
+      (mockExecutor.executeQuery as ReturnType<typeof vi.fn>).mockClear();
+      (mockExecutor.executeQuery as ReturnType<typeof vi.fn>).mockResolvedValue(
+        { rows: [] },
+      );
+
+      // Second call - cache should be expired
+      await manager.getSchema();
+      // Should make fresh database call for indexes after TTL expiration
+      expect(mockExecutor.executeQuery).toHaveBeenCalled();
+    });
+
+    it("should clear cache explicitly", () => {
+      // Should not throw
+      expect(() => manager.clearCache()).not.toThrow();
+    });
+  });
+
+  describe("describeTable", () => {
+    it("should throw validation error for invalid table name", async () => {
+      await expect(manager.describeTable("invalid-table-name")).rejects.toThrow(
+        ValidationError,
+      );
+      await expect(manager.describeTable("table;drop table")).rejects.toThrow(
+        ValidationError,
+      );
+    });
+
+    it("should correctly parsing view types", async () => {
+      // Mock column info
+      (mockExecutor.executeQuery as ReturnType<typeof vi.fn>)
+        .mockResolvedValueOnce({ rows: [] }) // columns
+        .mockResolvedValueOnce({
+          rows: [{ type: "VIEW", engine: null, rowCount: null }],
+        }); // table info
+
+      const result = await manager.describeTable("my_view");
+      expect(result.type).toBe("view");
+      expect(result.engine).toBeNull();
+    });
+
+    it("should handle missing table", async () => {
+      (mockExecutor.executeQuery as ReturnType<typeof vi.fn>)
+        .mockResolvedValueOnce({ rows: [] })
+        .mockResolvedValueOnce({ rows: [] });
+
+      const result = await manager.describeTable("non_existent");
+      expect(result.type).toBe("table"); // Default
+      expect(result.rowCount).toBeUndefined();
+    });
+
+    it("should handle qualified table names", async () => {
+      (mockExecutor.executeQuery as ReturnType<typeof vi.fn>)
+        .mockResolvedValueOnce({ rows: [] })
+        .mockResolvedValueOnce({ rows: [] });
+
+      await manager.describeTable("schema.table");
+
+      expect(mockExecutor.executeQuery).toHaveBeenCalledWith(
+        expect.stringContaining("TABLE_SCHEMA = ?"),
+        ["schema", "table"],
+      );
+    });
+  });
+
+  describe("getTableIndexes", () => {
+    it("should throw validation error for invalid table name", async () => {
+      await expect(
+        manager.getTableIndexes("invalid-table-name"),
+      ).rejects.toThrow(ValidationError);
+      await expect(manager.getTableIndexes("table;drop table")).rejects.toThrow(
+        ValidationError,
+      );
     });
 
-    describe('cache functionality', () => {
-        beforeEach(() => {
-            vi.useFakeTimers();
-        });
-
-        afterEach(() => {
-            vi.useRealTimers();
-        });
-
-        it('should cache getAllIndexes results', async () => {
-            (mockExecutor.executeQuery as ReturnType<typeof vi.fn>)
-                .mockResolvedValue({ rows: [] });
-
-            // First call - should query database
-            await manager.getSchema();
-            expect(mockExecutor.executeQuery).toHaveBeenCalledTimes(2); // listTables + getAllIndexes
-
-            // Second call - should use cache for indexes
-            (mockExecutor.executeQuery as ReturnType<typeof vi.fn>).mockClear();
-            (mockExecutor.executeQuery as ReturnType<typeof vi.fn>)
-                .mockResolvedValue({ rows: [] });
-            await manager.getSchema();
-            // Only listTables should be called, getAllIndexes is cached
-            expect(mockExecutor.executeQuery).toHaveBeenCalledTimes(1);
-        });
-
-        it('should expire cache after TTL', async () => {
-            (mockExecutor.executeQuery as ReturnType<typeof vi.fn>)
-                .mockResolvedValue({ rows: [] });
-
-            // First call
-            await manager.getSchema();
-
-            // Advance time past TTL (31 seconds)
-            vi.advanceTimersByTime(31000);
-
-            // Clear the mock to count fresh calls
-            (mockExecutor.executeQuery as ReturnType<typeof vi.fn>).mockClear();
-            (mockExecutor.executeQuery as ReturnType<typeof vi.fn>)
-                .mockResolvedValue({ rows: [] });
-
-            // Second call - cache should be expired
-            await manager.getSchema();
-            // Should make fresh database call for indexes after TTL expiration
-            expect(mockExecutor.executeQuery).toHaveBeenCalled();
-        });
-
-        it('should clear cache explicitly', () => {
-            // Should not throw
-            expect(() => manager.clearCache()).not.toThrow();
-        });
+    it("should handle qualified table names (schema.table)", async () => {
+      (mockExecutor.executeQuery as ReturnType<typeof vi.fn>).mockResolvedValue(
+        {
+          rows: [
+            {
+              name: "PRIMARY",
+              nonUnique: 0,
+              columnName: "id",
+              type: "BTREE",
+              cardinality: 100,
+            },
+          ],
+        },
+      );
+
+      const indexes = await manager.getTableIndexes("mydb.users");
+
+      expect(mockExecutor.executeQuery).toHaveBeenCalledWith(
+        expect.stringContaining("TABLE_SCHEMA = ?"),
+        ["mydb", "users"],
+      );
+      expect(indexes).toHaveLength(1);
     });
 
-    describe('describeTable', () => {
-        it('should throw validation error for invalid table name', async () => {
-            await expect(manager.describeTable('invalid-table-name')).rejects.toThrow(ValidationError);
-            await expect(manager.describeTable('table;drop table')).rejects.toThrow(ValidationError);
-        });
-
-        it('should correctly parsing view types', async () => {
-            // Mock column info
-            (mockExecutor.executeQuery as ReturnType<typeof vi.fn>)
-                .mockResolvedValueOnce({ rows: [] }) // columns
-                .mockResolvedValueOnce({
-                    rows: [{ type: 'VIEW', engine: null, rowCount: null }]
-                }); // table info
-
-            const result = await manager.describeTable('my_view');
-            expect(result.type).toBe('view');
-            expect(result.engine).toBeNull();
-        });
-
-        it('should handle missing table', async () => {
-            (mockExecutor.executeQuery as ReturnType<typeof vi.fn>)
-                .mockResolvedValueOnce({ rows: [] })
-                .mockResolvedValueOnce({ rows: [] });
-
-            const result = await manager.describeTable('non_existent');
-            expect(result.type).toBe('table'); // Default
-            expect(result.rowCount).toBeUndefined();
-        });
-
-        it('should handle qualified table names', async () => {
-            (mockExecutor.executeQuery as ReturnType<typeof vi.fn>)
-                .mockResolvedValueOnce({ rows: [] })
-                .mockResolvedValueOnce({ rows: [] });
-
-            await manager.describeTable('schema.table');
-
-            expect(mockExecutor.executeQuery).toHaveBeenCalledWith(
-                expect.stringContaining('TABLE_SCHEMA = ?'),
-                ['schema', 'table']
-            );
-        });
+    it("should group composite indexes correctly", async () => {
+      (mockExecutor.executeQuery as ReturnType<typeof vi.fn>).mockResolvedValue(
+        {
+          rows: [
+            {
+              name: "idx_composite",
+              nonUnique: 1,
+              columnName: "col1",
+              type: "BTREE",
+              cardinality: 100,
+            },
+            {
+              name: "idx_composite",
+              nonUnique: 1,
+              columnName: "col2",
+              type: "BTREE",
+              cardinality: 100,
+            },
+          ],
+        },
+      );
+
+      const indexes = await manager.getTableIndexes("users");
+
+      expect(indexes).toHaveLength(1);
+      expect(indexes[0].name).toBe("idx_composite");
+      expect(indexes[0].columns).toEqual(["col1", "col2"]);
+      expect(indexes[0].unique).toBe(false);
     });
 
-    describe('getTableIndexes', () => {
-        it('should throw validation error for invalid table name', async () => {
-            await expect(manager.getTableIndexes('invalid-table-name')).rejects.toThrow(ValidationError);
-            await expect(manager.getTableIndexes('table;drop table')).rejects.toThrow(ValidationError);
-        });
-
-        it('should handle qualified table names (schema.table)', async () => {
-            (mockExecutor.executeQuery as ReturnType<typeof vi.fn>).mockResolvedValue({
-                rows: [{ name: 'PRIMARY', nonUnique: 0, columnName: 'id', type: 'BTREE', cardinality: 100 }]
-            });
-
-            const indexes = await manager.getTableIndexes('mydb.users');
-
-            expect(mockExecutor.executeQuery).toHaveBeenCalledWith(
-                expect.stringContaining('TABLE_SCHEMA = ?'),
-                ['mydb', 'users']
-            );
-            expect(indexes).toHaveLength(1);
-        });
-
-        it('should group composite indexes correctly', async () => {
-            (mockExecutor.executeQuery as ReturnType<typeof vi.fn>).mockResolvedValue({
-                rows: [
-                    { name: 'idx_composite', nonUnique: 1, columnName: 'col1', type: 'BTREE', cardinality: 100 },
-                    { name: 'idx_composite', nonUnique: 1, columnName: 'col2', type: 'BTREE', cardinality: 100 }
-                ]
-            });
-
-            const indexes = await manager.getTableIndexes('users');
-
-            expect(indexes).toHaveLength(1);
-            expect(indexes[0].name).toBe('idx_composite');
-            expect(indexes[0].columns).toEqual(['col1', 'col2']);
-            expect(indexes[0].unique).toBe(false);
-        });
-
-        it('should handle different index types', async () => {
-            (mockExecutor.executeQuery as ReturnType<typeof vi.fn>).mockResolvedValue({
-                rows: [
-                    { name: 'PRIMARY', nonUnique: 0, columnName: 'id', type: 'BTREE' },
-                    { name: 'idx_fulltext', nonUnique: 1, columnName: 'bio', type: 'FULLTEXT' }
-                ]
-            });
-
-            const indexes = await manager.getTableIndexes('users');
-
-            expect(indexes).toHaveLength(2);
-            expect(indexes[0].type).toBe('BTREE');
-            expect(indexes[0].unique).toBe(true);
-            expect(indexes[1].type).toBe('FULLTEXT');
-        });
+    it("should handle different index types", async () => {
+      (mockExecutor.executeQuery as ReturnType<typeof vi.fn>).mockResolvedValue(
+        {
+          rows: [
+            { name: "PRIMARY", nonUnique: 0, columnName: "id", type: "BTREE" },
+            {
+              name: "idx_fulltext",
+              nonUnique: 1,
+              columnName: "bio",
+              type: "FULLTEXT",
+            },
+          ],
+        },
+      );
+
+      const indexes = await manager.getTableIndexes("users");
+
+      expect(indexes).toHaveLength(2);
+      expect(indexes[0].type).toBe("BTREE");
+      expect(indexes[0].unique).toBe(true);
+      expect(indexes[1].type).toBe("FULLTEXT");
     });
+  });
 });

package/src/adapters/mysql/index.ts

@@ -2,7 +2,7 @@
  * MySQL Adapter - Module Index
  */
 
-export { MySQLAdapter } from './MySQLAdapter.js';
+export { MySQLAdapter } from "./MySQLAdapter.js";
 
 // Re-export types
-export * from './types.js';
+export * from "./types.js";

package/src/adapters/mysql/prompts/__tests__/indexTuning.test.ts

@@ -1,32 +1,39 @@
+import { describe, it, expect } from "vitest";
+import { createMockRequestContext } from "../../../../__tests__/mocks/index.js";
+import { createIndexTuningPrompt } from "../indexTuning.js";
 
-import { describe, it, expect } from 'vitest';
-import { createMockRequestContext } from '../../../../__tests__/mocks/index.js';
-import { createIndexTuningPrompt } from '../indexTuning.js';
+describe("Index Tuning Prompt", () => {
+  it("should generate generic tuning advice when no table specified", async () => {
+    const prompt = createIndexTuningPrompt();
+    const result = await prompt.handler!({}, createMockRequestContext());
 
-describe('Index Tuning Prompt', () => {
+    expect(result).toContain(
+      "Analyze and optimize indexes across the database",
+    );
+    expect(result).toContain(
+      "Start by reviewing the `mysql://indexes` resource.",
+    );
+    expect(result).not.toContain("table: **");
+  });
 
-    it('should generate generic tuning advice when no table specified', async () => {
-        const prompt = createIndexTuningPrompt();
-        const result = await prompt.handler!({}, createMockRequestContext());
+  it("should generate table-specific tuning advice when table specified", async () => {
+    const prompt = createIndexTuningPrompt();
+    const result = await prompt.handler!(
+      { table: "users" },
+      createMockRequestContext(),
+    );
 
-        expect(result).toContain('Analyze and optimize indexes across the database');
-        expect(result).toContain('Start by reviewing the `mysql://indexes` resource.');
-        expect(result).not.toContain('table: **');
-    });
+    expect(result).toContain(
+      "Analyze and optimize indexes for table: **users**",
+    );
+    expect(result).toContain("Start by analyzing indexes on table **users**.");
+  });
 
-    it('should generate table-specific tuning advice when table specified', async () => {
-        const prompt = createIndexTuningPrompt();
-        const result = await prompt.handler!({ table: 'users' }, createMockRequestContext());
-
-        expect(result).toContain('Analyze and optimize indexes for table: **users**');
-        expect(result).toContain('Start by analyzing indexes on table **users**.');
-    });
-
-    it('should have correct required argument metadata', () => {
-        const prompt = createIndexTuningPrompt();
-        expect(prompt.name).toBe('mysql_index_tuning');
-        expect(prompt.arguments).toHaveLength(1);
-        expect(prompt.arguments![0].name).toBe('table');
-        expect(prompt.arguments![0].required).toBe(false);
-    });
+  it("should have correct required argument metadata", () => {
+    const prompt = createIndexTuningPrompt();
+    expect(prompt.name).toBe("mysql_index_tuning");
+    expect(prompt.arguments).toHaveLength(1);
+    expect(prompt.arguments![0].name).toBe("table");
+    expect(prompt.arguments![0].required).toBe(false);
+  });
 });