@neverinfamous/mysql-mcp 2.1.0 → 2.3.0

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

@@ -1,117 +1,129 @@
 /**
  * mysql-mcp - Resources Unit Tests
- * 
+ *
  * Tests for resource definitions using centralized mocks.
  */
 
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { getMySQLResources } from '../index.js';
-import type { MySQLAdapter } from '../../MySQLAdapter.js';
-import { createMockMySQLAdapter, createMockRequestContext, createMockQueryResult } from '../../../../__tests__/mocks/index.js';
-
-describe('getMySQLResources', () => {
-    let resources: ReturnType<typeof getMySQLResources>;
-
-    beforeEach(() => {
-        vi.clearAllMocks();
-        resources = getMySQLResources(createMockMySQLAdapter() as unknown as MySQLAdapter);
-    });
-
-    it('should return 18 resources', () => {
-        expect(resources).toHaveLength(18);
-    });
-
-    it('should have handler functions for all resources', () => {
-        for (const resource of resources) {
-            expect(typeof resource.handler).toBe('function');
-        }
-    });
-
-    it('should have descriptions for all resources', () => {
-        for (const resource of resources) {
-            expect(resource.description).toBeDefined();
-            expect(resource.description.length).toBeGreaterThan(0);
-        }
-    });
-
-    it('should have unique URIs for all resources', () => {
-        const uris = resources.map(r => r.uri);
-        const uniqueUris = new Set(uris);
-        expect(uniqueUris.size).toBe(uris.length);
-    });
-
-    it('should have URIs starting with mysql://', () => {
-        for (const resource of resources) {
-            expect(resource.uri.startsWith('mysql://')).toBe(true);
-        }
-    });
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { getMySQLResources } from "../index.js";
+import type { MySQLAdapter } from "../../MySQLAdapter.js";
+import {
+  createMockMySQLAdapter,
+  createMockRequestContext,
+  createMockQueryResult,
+} from "../../../../__tests__/mocks/index.js";
+
+describe("getMySQLResources", () => {
+  let resources: ReturnType<typeof getMySQLResources>;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    resources = getMySQLResources(
+      createMockMySQLAdapter() as unknown as MySQLAdapter,
+    );
+  });
+
+  it("should return 18 resources", () => {
+    expect(resources).toHaveLength(18);
+  });
+
+  it("should have handler functions for all resources", () => {
+    for (const resource of resources) {
+      expect(typeof resource.handler).toBe("function");
+    }
+  });
+
+  it("should have descriptions for all resources", () => {
+    for (const resource of resources) {
+      expect(resource.description).toBeDefined();
+      expect(resource.description.length).toBeGreaterThan(0);
+    }
+  });
+
+  it("should have unique URIs for all resources", () => {
+    const uris = resources.map((r) => r.uri);
+    const uniqueUris = new Set(uris);
+    expect(uniqueUris.size).toBe(uris.length);
+  });
+
+  it("should have URIs starting with mysql://", () => {
+    for (const resource of resources) {
+      expect(resource.uri.startsWith("mysql://")).toBe(true);
+    }
+  });
 });
 
-describe('Resource Handler Smoke Tests', () => {
-    let mockAdapter: ReturnType<typeof createMockMySQLAdapter>;
-    let mockContext: ReturnType<typeof createMockRequestContext>;
-    let resources: ReturnType<typeof getMySQLResources>;
-
-    beforeEach(() => {
-        vi.clearAllMocks();
-        mockAdapter = createMockMySQLAdapter();
-        mockContext = createMockRequestContext();
-        resources = getMySQLResources(mockAdapter as unknown as MySQLAdapter);
-    });
-
-    const findResource = (uri: string) => resources.find(r => r.uri === uri);
-
-    it('mysql://tables handler should call listTables', async () => {
-        const resource = findResource('mysql://tables');
-        expect(resource).toBeDefined();
-
-        const result = await resource!.handler('mysql://tables', mockContext);
-        expect(mockAdapter.listTables).toHaveBeenCalled();
-        expect(result).toHaveProperty('tables');
-    });
-
-    it('mysql://schema handler should call getSchema', async () => {
-        const resource = findResource('mysql://schema');
-        expect(resource).toBeDefined();
-
-        const result = await resource!.handler('mysql://schema', mockContext);
-        expect(mockAdapter.getSchema).toHaveBeenCalled();
-        expect(result).toHaveProperty('tables');
-    });
-
-    it('mysql://variables handler should execute query', async () => {
-        mockAdapter.executeQuery.mockResolvedValue(createMockQueryResult([
-            { Variable_name: 'version', Value: '8.0.35' }
-        ]));
-
-        const resource = findResource('mysql://variables');
-        expect(resource).toBeDefined();
-
-        await resource!.handler('mysql://variables', mockContext);
-        expect(mockAdapter.executeQuery).toHaveBeenCalledWith(expect.stringContaining('SHOW'));
-    });
-
-    it('mysql://status handler should execute query', async () => {
-        mockAdapter.executeQuery.mockResolvedValue(createMockQueryResult([
-            { Variable_name: 'Uptime', Value: '86400' }
-        ]));
-
-        const resource = findResource('mysql://status');
-        expect(resource).toBeDefined();
-
-        await resource!.handler('mysql://status', mockContext);
-        expect(mockAdapter.executeQuery).toHaveBeenCalledWith(expect.stringContaining('SHOW'));
-    });
-
-    it('mysql://processlist handler should execute processlist query', async () => {
-        mockAdapter.executeQuery.mockResolvedValue(createMockQueryResult([
-            { Id: 1, User: 'root', Command: 'Query' }
-        ]));
-
-        const resource = findResource('mysql://processlist');
-        expect(resource).toBeDefined();
-
-        await resource!.handler('mysql://processlist', mockContext);
-        expect(mockAdapter.executeQuery).toHaveBeenCalledWith(expect.stringContaining('PROCESSLIST'));
-    });
+describe("Resource Handler Smoke Tests", () => {
+  let mockAdapter: ReturnType<typeof createMockMySQLAdapter>;
+  let mockContext: ReturnType<typeof createMockRequestContext>;
+  let resources: ReturnType<typeof getMySQLResources>;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mockAdapter = createMockMySQLAdapter();
+    mockContext = createMockRequestContext();
+    resources = getMySQLResources(mockAdapter as unknown as MySQLAdapter);
+  });
+
+  const findResource = (uri: string) => resources.find((r) => r.uri === uri);
+
+  it("mysql://tables handler should call listTables", async () => {
+    const resource = findResource("mysql://tables");
+    expect(resource).toBeDefined();
+
+    const result = await resource!.handler("mysql://tables", mockContext);
+    expect(mockAdapter.listTables).toHaveBeenCalled();
+    expect(result).toHaveProperty("tables");
+  });
+
+  it("mysql://schema handler should call getSchema", async () => {
+    const resource = findResource("mysql://schema");
+    expect(resource).toBeDefined();
+
+    const result = await resource!.handler("mysql://schema", mockContext);
+    expect(mockAdapter.getSchema).toHaveBeenCalled();
+    expect(result).toHaveProperty("tables");
+  });
+
+  it("mysql://variables handler should execute query", async () => {
+    mockAdapter.executeQuery.mockResolvedValue(
+      createMockQueryResult([{ Variable_name: "version", Value: "8.0.35" }]),
+    );
+
+    const resource = findResource("mysql://variables");
+    expect(resource).toBeDefined();
+
+    await resource!.handler("mysql://variables", mockContext);
+    expect(mockAdapter.executeQuery).toHaveBeenCalledWith(
+      expect.stringContaining("SHOW"),
+    );
+  });
+
+  it("mysql://status handler should execute query", async () => {
+    mockAdapter.executeQuery.mockResolvedValue(
+      createMockQueryResult([{ Variable_name: "Uptime", Value: "86400" }]),
+    );
+
+    const resource = findResource("mysql://status");
+    expect(resource).toBeDefined();
+
+    await resource!.handler("mysql://status", mockContext);
+    expect(mockAdapter.executeQuery).toHaveBeenCalledWith(
+      expect.stringContaining("SHOW"),
+    );
+  });
+
+  it("mysql://processlist handler should execute processlist query", async () => {
+    mockAdapter.executeQuery.mockResolvedValue(
+      createMockQueryResult([{ Id: 1, User: "root", Command: "Query" }]),
+    );
+
+    const resource = findResource("mysql://processlist");
+    expect(resource).toBeDefined();
+
+    await resource!.handler("mysql://processlist", mockContext);
+    expect(mockAdapter.executeQuery).toHaveBeenCalledWith(
+      expect.stringContaining("PROCESSLIST"),
+    );
+  });
 });

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

@@ -1,30 +1,36 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { createSchemaResource } from "../schema.js";
+import type { MySQLAdapter } from "../../MySQLAdapter.js";
+import {
+  createMockMySQLAdapter,
+  createMockRequestContext,
+} from "../../../../__tests__/mocks/index.js";
 
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { createSchemaResource } from '../schema.js';
-import type { MySQLAdapter } from '../../MySQLAdapter.js';
-import { createMockMySQLAdapter, createMockRequestContext } from '../../../../__tests__/mocks/index.js';
+describe("Schema Resource", () => {
+  let mockAdapter: ReturnType<typeof createMockMySQLAdapter>;
+  let mockContext: ReturnType<typeof createMockRequestContext>;
 
-describe('Schema 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 call getSchema adapter method", async () => {
+    const resource = createSchemaResource(
+      mockAdapter as unknown as MySQLAdapter,
+    );
+    await resource.handler("mysql://schema", mockContext);
 
-    it('should call getSchema adapter method', async () => {
-        const resource = createSchemaResource(mockAdapter as unknown as MySQLAdapter);
-        await resource.handler('mysql://schema', mockContext);
+    expect(mockAdapter.getSchema).toHaveBeenCalled();
+  });
 
-        expect(mockAdapter.getSchema).toHaveBeenCalled();
-    });
+  it("should return schema information", async () => {
+    const resource = createSchemaResource(
+      mockAdapter as unknown as MySQLAdapter,
+    );
+    const result = await resource.handler("mysql://schema", mockContext);
 
-    it('should return schema information', async () => {
-        const resource = createSchemaResource(mockAdapter as unknown as MySQLAdapter);
-        const result = await resource.handler('mysql://schema', mockContext);
-
-        expect(result).toHaveProperty('tables');
-    });
+    expect(result).toHaveProperty("tables");
+  });
 });

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

@@ -1,47 +1,60 @@
-
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { createMockMySQLAdapter, createMockQueryResult, createMockRequestContext } from '../../../../__tests__/mocks/index.js';
-import { createSpatialResource } from '../spatial.js';
-import type { MySQLAdapter } from '../../MySQLAdapter.js';
-
-describe('Spatial Resource', () => {
-    let mockAdapter: ReturnType<typeof createMockMySQLAdapter>;
-    let mockContext: ReturnType<typeof createMockRequestContext>;
-
-    beforeEach(() => {
-        vi.clearAllMocks();
-        mockAdapter = createMockMySQLAdapter();
-        mockContext = createMockRequestContext();
-    });
-
-    it('should return spatial columns information', async () => {
-        mockAdapter.executeQuery.mockResolvedValueOnce(createMockQueryResult([
-            { table_name: 'locations', column_name: 'geom', data_type: 'geometry' }
-        ]));
-        mockAdapter.executeQuery.mockResolvedValueOnce(createMockQueryResult([])); // spatial indexes
-
-        const resource = createSpatialResource(mockAdapter as unknown as MySQLAdapter);
-        const result = await resource.handler('mysql://spatial', mockContext);
-
-        expect(result).toBeDefined();
-        // @ts-ignore
-        expect(result.spatialColumns).toHaveLength(1);
-        // @ts-ignore
-        expect(result.spatialIndexCount).toBe(0);
-    });
-
-    it('should handle null query results', async () => {
-        mockAdapter.executeQuery.mockResolvedValueOnce(createMockQueryResult(null as any)); // Columns
-        mockAdapter.executeQuery.mockResolvedValueOnce(createMockQueryResult(null as any)); // Indexes
-
-        const resource = createSpatialResource(mockAdapter as unknown as MySQLAdapter);
-        const result = await resource.handler('mysql://spatial', mockContext);
-
-        expect(result).toEqual({
-            spatialColumnCount: 0,
-            spatialColumns: [],
-            spatialIndexCount: 0,
-            spatialIndexes: []
-        });
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import {
+  createMockMySQLAdapter,
+  createMockQueryResult,
+  createMockRequestContext,
+} from "../../../../__tests__/mocks/index.js";
+import { createSpatialResource } from "../spatial.js";
+import type { MySQLAdapter } from "../../MySQLAdapter.js";
+
+describe("Spatial Resource", () => {
+  let mockAdapter: ReturnType<typeof createMockMySQLAdapter>;
+  let mockContext: ReturnType<typeof createMockRequestContext>;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mockAdapter = createMockMySQLAdapter();
+    mockContext = createMockRequestContext();
+  });
+
+  it("should return spatial columns information", async () => {
+    mockAdapter.executeQuery.mockResolvedValueOnce(
+      createMockQueryResult([
+        { table_name: "locations", column_name: "geom", data_type: "geometry" },
+      ]),
+    );
+    mockAdapter.executeQuery.mockResolvedValueOnce(createMockQueryResult([])); // spatial indexes
+
+    const resource = createSpatialResource(
+      mockAdapter as unknown as MySQLAdapter,
+    );
+    const result = await resource.handler("mysql://spatial", mockContext);
+
+    expect(result).toBeDefined();
+    // @ts-ignore
+    expect(result.spatialColumns).toHaveLength(1);
+    // @ts-ignore
+    expect(result.spatialIndexCount).toBe(0);
+  });
+
+  it("should handle null query results", async () => {
+    mockAdapter.executeQuery.mockResolvedValueOnce(
+      createMockQueryResult(null as any),
+    ); // Columns
+    mockAdapter.executeQuery.mockResolvedValueOnce(
+      createMockQueryResult(null as any),
+    ); // Indexes
+
+    const resource = createSpatialResource(
+      mockAdapter as unknown as MySQLAdapter,
+    );
+    const result = await resource.handler("mysql://spatial", mockContext);
+
+    expect(result).toEqual({
+      spatialColumnCount: 0,
+      spatialColumns: [],
+      spatialIndexCount: 0,
+      spatialIndexes: [],
     });
+  });
 });

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

@@ -1,58 +1,75 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { createStatusResource } from "../status.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 { createStatusResource } from '../status.js';
-import type { MySQLAdapter } from '../../MySQLAdapter.js';
-import { createMockMySQLAdapter, createMockRequestContext, createMockQueryResult } from '../../../../__tests__/mocks/index.js';
+describe("Status Resource", () => {
+  let mockAdapter: ReturnType<typeof createMockMySQLAdapter>;
+  let mockContext: ReturnType<typeof createMockRequestContext>;
 
-describe('Status 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 map query results to status object", async () => {
+    mockAdapter.executeQuery.mockResolvedValueOnce(
+      createMockQueryResult([
+        { Variable_name: "Uptime", Value: "1000" },
+        { Variable_name: "Threads_connected", Value: "5" },
+      ]),
+    );
+
+    const resource = createStatusResource(
+      mockAdapter as unknown as MySQLAdapter,
+    );
+    const result = await resource.handler("mysql://status", mockContext);
 
-    it('should map query results to status object', async () => {
-        mockAdapter.executeQuery.mockResolvedValueOnce(createMockQueryResult([
-            { Variable_name: 'Uptime', Value: '1000' },
-            { Variable_name: 'Threads_connected', Value: '5' }
-        ]));
-
-        const resource = createStatusResource(mockAdapter as unknown as MySQLAdapter);
-        const result = await resource.handler('mysql://status', mockContext);
-
-        expect(result).toEqual({
-            status: {
-                'Uptime': '1000',
-                'Threads_connected': '5'
-            }
-        });
-        expect(mockAdapter.executeQuery).toHaveBeenCalledWith('SHOW GLOBAL STATUS');
+    expect(result).toEqual({
+      status: {
+        Uptime: "1000",
+        Threads_connected: "5",
+      },
     });
+    expect(mockAdapter.executeQuery).toHaveBeenCalledWith("SHOW GLOBAL STATUS");
+  });
 
-    it('should handle empty results', async () => {
-        mockAdapter.executeQuery.mockResolvedValueOnce(createMockQueryResult([]));
+  it("should handle empty results", async () => {
+    mockAdapter.executeQuery.mockResolvedValueOnce(createMockQueryResult([]));
 
-        const resource = createStatusResource(mockAdapter as unknown as MySQLAdapter);
-        const result = await resource.handler('mysql://status', mockContext);
+    const resource = createStatusResource(
+      mockAdapter as unknown as MySQLAdapter,
+    );
+    const result = await resource.handler("mysql://status", mockContext);
 
-        expect(result).toEqual({ status: {} });
-    });
+    expect(result).toEqual({ status: {} });
+  });
 
-    it('should handle null query results', async () => {
-        mockAdapter.executeQuery.mockResolvedValueOnce(createMockQueryResult(null as any));
+  it("should handle null query results", async () => {
+    mockAdapter.executeQuery.mockResolvedValueOnce(
+      createMockQueryResult(null as any),
+    );
 
-        const resource = createStatusResource(mockAdapter as unknown as MySQLAdapter);
-        const result = await resource.handler('mysql://status', mockContext);
+    const resource = createStatusResource(
+      mockAdapter as unknown as MySQLAdapter,
+    );
+    const result = await resource.handler("mysql://status", mockContext);
 
-        expect(result).toEqual({ status: {} });
-    });
+    expect(result).toEqual({ status: {} });
+  });
 
-    it('should propagate errors', async () => {
-        mockAdapter.executeQuery.mockRejectedValue(new Error('Connection failed'));
-        const resource = createStatusResource(mockAdapter as unknown as MySQLAdapter);
-        await expect(resource.handler('mysql://status', mockContext)).rejects.toThrow('Connection failed');
-    });
+  it("should propagate errors", async () => {
+    mockAdapter.executeQuery.mockRejectedValue(new Error("Connection failed"));
+    const resource = createStatusResource(
+      mockAdapter as unknown as MySQLAdapter,
+    );
+    await expect(
+      resource.handler("mysql://status", mockContext),
+    ).rejects.toThrow("Connection failed");
+  });
 });