@neverinfamous/mysql-mcp 2.1.0

package/src/progress/__tests__/ProgressReporter.test.ts

@@ -0,0 +1,263 @@
+/**
+ * mysql-mcp - Progress Reporter Unit Tests
+ * 
+ * Tests for ProgressReporter and ProgressReporterFactory functionality
+ * including progress notifications, completion states, and error handling.
+ */
+
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { ProgressReporter } from '../ProgressReporter.js';
+
+describe('ProgressReporter', () => {
+    let mockServer: {
+        server: {
+            notification: ReturnType<typeof vi.fn>;
+        };
+    };
+
+    beforeEach(() => {
+        vi.clearAllMocks();
+        mockServer = {
+            server: {
+                notification: vi.fn()
+            }
+        };
+    });
+
+    describe('Construction', () => {
+        it('should create reporter with token', () => {
+            const reporter = new ProgressReporter(mockServer as never, 'token-123');
+            expect(reporter.getToken()).toBe('token-123');
+        });
+
+        it('should accept numeric token', () => {
+            const reporter = new ProgressReporter(mockServer as never, 42);
+            expect(reporter.getToken()).toBe(42);
+        });
+
+        it('should start in active state', () => {
+            const reporter = new ProgressReporter(mockServer as never, 'token');
+            expect(reporter.isActive()).toBe(true);
+        });
+    });
+
+    describe('report()', () => {
+        it('should send progress notification', () => {
+            const reporter = new ProgressReporter(mockServer as never, 'token-123');
+            reporter.report(50, 100, 'Processing...');
+
+            expect(mockServer.server.notification).toHaveBeenCalledWith({
+                method: 'notifications/progress',
+                params: {
+                    progressToken: 'token-123',
+                    progress: 50,
+                    total: 100,
+                    message: 'Processing...'
+                }
+            });
+        });
+
+        it('should work without total', () => {
+            const reporter = new ProgressReporter(mockServer as never, 'token');
+            reporter.report(25);
+
+            expect(mockServer.server.notification).toHaveBeenCalledWith({
+                method: 'notifications/progress',
+                params: expect.objectContaining({
+                    progress: 25,
+                    total: undefined
+                })
+            });
+        });
+
+        it('should work without message', () => {
+            const reporter = new ProgressReporter(mockServer as never, 'token');
+            reporter.report(75, 100);
+
+            expect(mockServer.server.notification).toHaveBeenCalledWith({
+                method: 'notifications/progress',
+                params: expect.objectContaining({
+                    progress: 75,
+                    total: 100,
+                    message: undefined
+                })
+            });
+        });
+
+        it('should not report after completion', () => {
+            const reporter = new ProgressReporter(mockServer as never, 'token');
+            reporter.complete();
+            mockServer.server.notification.mockClear();
+
+            reporter.report(50);
+
+            expect(mockServer.server.notification).not.toHaveBeenCalled();
+        });
+    });
+
+    describe('complete()', () => {
+        it('should send completion notification with default message', () => {
+            const reporter = new ProgressReporter(mockServer as never, 'token');
+            reporter.complete();
+
+            expect(mockServer.server.notification).toHaveBeenCalledWith({
+                method: 'notifications/progress',
+                params: {
+                    progressToken: 'token',
+                    progress: 1,
+                    total: 1,
+                    message: 'Complete'
+                }
+            });
+        });
+
+        it('should send completion notification with custom message', () => {
+            const reporter = new ProgressReporter(mockServer as never, 'token');
+            reporter.complete('All done!');
+
+            expect(mockServer.server.notification).toHaveBeenCalledWith({
+                method: 'notifications/progress',
+                params: expect.objectContaining({
+                    message: 'All done!'
+                })
+            });
+        });
+
+        it('should set reporter to inactive', () => {
+            const reporter = new ProgressReporter(mockServer as never, 'token');
+            expect(reporter.isActive()).toBe(true);
+
+            reporter.complete();
+
+            expect(reporter.isActive()).toBe(false);
+        });
+
+        it('should only complete once', () => {
+            const reporter = new ProgressReporter(mockServer as never, 'token');
+            reporter.complete('First');
+            reporter.complete('Second');
+
+            expect(mockServer.server.notification).toHaveBeenCalledTimes(1);
+        });
+    });
+
+    describe('error()', () => {
+        it('should send error notification', () => {
+            const reporter = new ProgressReporter(mockServer as never, 'token');
+            reporter.error('Something went wrong');
+
+            expect(mockServer.server.notification).toHaveBeenCalledWith({
+                method: 'notifications/progress',
+                params: {
+                    progressToken: 'token',
+                    progress: 0,
+                    message: 'Error: Something went wrong'
+                }
+            });
+        });
+
+        it('should set reporter to inactive', () => {
+            const reporter = new ProgressReporter(mockServer as never, 'token');
+            reporter.error('Failed');
+
+            expect(reporter.isActive()).toBe(false);
+        });
+
+        it('should not error after completion', () => {
+            const reporter = new ProgressReporter(mockServer as never, 'token');
+            reporter.complete();
+            mockServer.server.notification.mockClear();
+
+            reporter.error('Should not send');
+
+            expect(mockServer.server.notification).not.toHaveBeenCalled();
+        });
+    });
+
+    describe('Error Handling', () => {
+        it('should handle notification errors gracefully', () => {
+            mockServer.server.notification.mockImplementation(() => {
+                throw new Error('Transport error');
+            });
+
+            const reporter = new ProgressReporter(mockServer as never, 'token');
+
+            // Should not throw
+            expect(() => reporter.report(50)).not.toThrow();
+            expect(() => reporter.complete()).not.toThrow();
+        });
+    });
+});
+
+describe('ProgressReporterFactory', () => {
+    let mockServer: {
+        server: {
+            notification: ReturnType<typeof vi.fn>;
+        };
+    };
+
+    beforeEach(() => {
+        vi.clearAllMocks();
+        vi.resetModules();
+        mockServer = {
+            server: {
+                notification: vi.fn()
+            }
+        };
+    });
+
+    afterEach(() => {
+        vi.resetModules();
+    });
+
+    describe('Availability', () => {
+        it('should report unavailable before server set', async () => {
+            const { progressFactory: factory } = await import('../ProgressReporter.js');
+            expect(factory.isAvailable()).toBe(false);
+        });
+
+        it('should report available after server set', async () => {
+            const { progressFactory: factory } = await import('../ProgressReporter.js');
+            factory.setServer(mockServer as never);
+            expect(factory.isAvailable()).toBe(true);
+        });
+    });
+
+    describe('create()', () => {
+        it('should return null when no server set', async () => {
+            const { progressFactory: factory } = await import('../ProgressReporter.js');
+            const reporter = factory.create('token');
+            expect(reporter).toBeNull();
+        });
+
+        it('should return null when no token provided', async () => {
+            const { progressFactory: factory } = await import('../ProgressReporter.js');
+            factory.setServer(mockServer as never);
+            const reporter = factory.create(undefined);
+            expect(reporter).toBeNull();
+        });
+
+        it('should create reporter when server and token available', async () => {
+            const { progressFactory: factory } = await import('../ProgressReporter.js');
+            factory.setServer(mockServer as never);
+            const reporter = factory.create('my-token');
+
+            expect(reporter).not.toBeNull();
+            expect(reporter?.getToken()).toBe('my-token');
+        });
+
+        it('should create functional reporter', async () => {
+            const { progressFactory: factory } = await import('../ProgressReporter.js');
+            factory.setServer(mockServer as never);
+            const reporter = factory.create('test-token');
+
+            reporter?.report(10, 100, 'Testing');
+
+            expect(mockServer.server.notification).toHaveBeenCalledWith(
+                expect.objectContaining({
+                    method: 'notifications/progress'
+                })
+            );
+        });
+    });
+});

package/src/progress/index.ts

@@ -0,0 +1,7 @@
+/**
+ * Progress Module Index
+ * 
+ * Re-exports progress notification utilities.
+ */
+
+export { ProgressReporter, progressFactory, type ProgressToken } from './ProgressReporter.js';

package/src/server/McpServer.ts

@@ -0,0 +1,341 @@
+/**
+ * mysql-mcp - MCP Server
+ * 
+ * Main MCP server implementation with adapter registration,
+ * tool filtering, and transport handling.
+ */
+
+import { McpServer as SdkMcpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { generateInstructions } from '../constants/ServerInstructions.js';
+import type { DatabaseAdapter } from '../adapters/DatabaseAdapter.js';
+import type { McpServerConfig, TransportType, DatabaseConfig, ToolFilterConfig } from '../types/index.js';
+import { parseToolFilter, getFilterSummary } from '../filtering/ToolFilter.js';
+import { logger } from '../utils/logger.js';
+import { mcpLogger } from '../logging/McpLogging.js';
+import { progressFactory } from '../progress/ProgressReporter.js';
+import { OAuthResourceServer } from '../auth/OAuthResourceServer.js';
+import { TokenValidator } from '../auth/TokenValidator.js';
+
+/**
+ * Default server configuration
+ */
+export const DEFAULT_CONFIG: McpServerConfig = {
+    name: 'mysql-mcp',
+    version: '0.1.0',
+    transport: 'stdio',
+    databases: []
+};
+
+/**
+ * MySQL MCP Server
+ */
+export class McpServer {
+    private server: SdkMcpServer;
+    private adapters = new Map<string, DatabaseAdapter>();
+    private config: McpServerConfig;
+    private toolFilter: ToolFilterConfig;
+    private started = false;
+    private activeTransport: { stop(): Promise<void> } | null = null;
+
+    constructor(config: Partial<McpServerConfig> = {}) {
+        this.config = { ...DEFAULT_CONFIG, ...config };
+        this.toolFilter = parseToolFilter(this.config.toolFilter);
+
+        // Generate dynamic instructions based on enabled tools
+        const instructions = generateInstructions(
+            this.toolFilter.enabledTools,
+            [], // Resources will be added when adapter is registered
+            []  // Prompts will be added when adapter is registered
+        );
+
+        this.server = new SdkMcpServer(
+            {
+                name: this.config.name,
+                version: this.config.version
+            },
+            {
+                capabilities: {
+                    logging: {}
+                },
+                instructions
+            }
+        );
+
+        // Initialize MCP protocol logging so clients can receive log messages
+        mcpLogger.setServer(this.server);
+
+        // Initialize MCP protocol progress reporting for long-running operations
+        progressFactory.setServer(this.server);
+
+        // Log tool filter summary
+        if (this.toolFilter.rules.length > 0) {
+            logger.info(getFilterSummary(this.toolFilter));
+        }
+
+        // Log server initialization with capabilities
+        logger.info('MCP Server initialized', {
+            name: this.config.name,
+            version: this.config.version,
+            toolFilter: this.config.toolFilter ?? 'none',
+            capabilities: ['logging']
+        });
+    }
+
+    /**
+     * Register a database adapter
+     */
+    registerAdapter(adapter: DatabaseAdapter, alias?: string): void {
+        const key = alias ?? `${adapter.type}:default`;
+
+        if (this.adapters.has(key)) {
+            logger.warn(`Adapter already registered: ${key}`);
+            return;
+        }
+
+        this.adapters.set(key, adapter);
+
+        // Get counts before registration
+        const allTools = adapter.getToolDefinitions();
+        const allResources = adapter.getResourceDefinitions();
+        const allPrompts = adapter.getPromptDefinitions();
+
+        // Register adapter's tools, resources, and prompts
+        adapter.registerTools(this.server, this.toolFilter.enabledTools);
+        adapter.registerResources(this.server);
+        adapter.registerPrompts(this.server);
+
+        // Count enabled tools
+        const enabledToolCount = allTools.filter(t => this.toolFilter.enabledTools.has(t.name)).length;
+
+        logger.info(`Registered adapter: ${adapter.name} (${key})`);
+        logger.info(`  Tools: ${enabledToolCount}/${allTools.length} enabled`);
+        logger.info(`  Resources: ${allResources.length}`);
+        logger.info(`  Prompts: ${allPrompts.length}`);
+        mcpLogger.info(`Database adapter registered: ${adapter.name} (${enabledToolCount} tools, ${allResources.length} resources, ${allPrompts.length} prompts)`);
+    }
+
+    /**
+     * Get a registered adapter by key
+     */
+    getAdapter(key: string): DatabaseAdapter | undefined {
+        return this.adapters.get(key);
+    }
+
+    /**
+     * Get all registered adapters
+     */
+    getAdapters(): Map<string, DatabaseAdapter> {
+        return this.adapters;
+    }
+
+    /**
+     * Start the MCP server
+     */
+    async start(): Promise<void> {
+        if (this.started) {
+            logger.warn('Server already started');
+            return;
+        }
+
+        logger.info('Starting MCP server...');
+
+        try {
+            await this.startTransport(this.config.transport);
+            this.started = true;
+
+            // Enable MCP protocol logging now that transport is connected
+            mcpLogger.setConnected(true);
+
+            logger.info('Server started successfully');
+            mcpLogger.info('MySQL MCP server ready', { transport: this.config.transport });
+        } catch (error) {
+            logger.error('Failed to start server', { error: String(error) });
+            throw error;
+        }
+    }
+
+    /**
+     * Start the specified transport
+     */
+    private async startTransport(transport: TransportType): Promise<void> {
+        switch (transport) {
+            case 'stdio':
+                await this.startStdioTransport();
+                break;
+            case 'http':
+            case 'sse': {
+                const { createHttpTransport } = await import('../transports/http.js');
+                const port = this.config.port ?? 3000;
+
+                const transport = createHttpTransport({
+                    port,
+                    host: 'localhost', // Default to localhost, could be configurable
+                    corsOrigins: ['*'], // Allow all for now, or make configurable
+                    // Pass OAuth config if enabled
+                    ...(this.config.oauth?.enabled ? {
+                        resourceServer: this.createOAuthResourceServer(),
+                        tokenValidator: this.createTokenValidator()
+                    } : {})
+                }, (sseTransport) => {
+                    logger.info('New SSE connection');
+                    void this.server.connect(sseTransport);
+                });
+
+                await transport.start();
+                this.activeTransport = transport;
+                break;
+            }
+            default:
+                throw new Error(`Unknown transport: ${String(transport)}`);
+        }
+    }
+
+    /**
+     * Start stdio transport
+     */
+    private async startStdioTransport(): Promise<void> {
+        const transport = new StdioServerTransport();
+        await this.server.connect(transport);
+    }
+
+    /**
+     * Stop the MCP server
+     */
+    async stop(): Promise<void> {
+        if (!this.started) {
+            return;
+        }
+
+        logger.info('Stopping MCP server...');
+
+        // Disable MCP logging before disconnecting
+        mcpLogger.setConnected(false);
+
+        // Disconnect all adapters
+        for (const [key, adapter] of this.adapters) {
+            try {
+                await adapter.disconnect();
+                logger.info(`Disconnected adapter: ${key}`);
+            } catch (error) {
+                logger.error(`Error disconnecting adapter ${key}`, { error: String(error) });
+            }
+        }
+
+        if (this.activeTransport) {
+            try {
+                await this.activeTransport.stop();
+            } catch (error) {
+                logger.error('Error stopping transport', { error: String(error) });
+            }
+            this.activeTransport = null;
+        }
+
+        await this.server.close();
+        this.started = false;
+        logger.info('Server stopped');
+    }
+
+    /**
+     * Get server configuration
+     */
+    getConfig(): McpServerConfig {
+        return { ...this.config };
+    }
+
+    /**
+     * Get tool filter configuration
+     */
+    getToolFilter(): ToolFilterConfig {
+        return this.toolFilter;
+    }
+
+    /**
+     * Check if server is running
+     */
+    isRunning(): boolean {
+        return this.started;
+    }
+
+    /**
+     * Get the underlying MCP SDK server instance
+     */
+    getSdkServer(): SdkMcpServer {
+        return this.server;
+    }
+
+    /**
+     * Create OAuth resource server from config
+     */
+    private createOAuthResourceServer(): OAuthResourceServer {
+        if (!this.config.oauth?.enabled) {
+            throw new Error('OAuth is not enabled');
+        }
+
+        // Use audience as resource ID if not explicitly configured in future
+        const resourceId = this.config.oauth.audience ?? 'mysql-mcp';
+
+        const issuer = this.config.oauth.issuer;
+        if (!issuer) {
+            throw new Error('OAuth issuer is required');
+        }
+
+        return new OAuthResourceServer({
+            resource: resourceId,
+            authorizationServers: [issuer],
+            scopesSupported: ['read', 'write', 'admin'],
+            bearerMethodsSupported: ['header']
+        });
+    }
+
+    /**
+     * Create token validator from config
+     */
+    private createTokenValidator(): TokenValidator {
+        if (!this.config.oauth?.enabled) {
+            throw new Error('OAuth is not enabled');
+        }
+
+        if (!this.config.oauth.jwksUri) {
+            throw new Error('OAuth JWKS URI is required for validation');
+        }
+
+        const issuer = this.config.oauth.issuer;
+        const audience = this.config.oauth.audience;
+        if (!issuer || !audience) {
+            throw new Error('OAuth issuer and audience are required');
+        }
+
+        return new TokenValidator({
+            issuer,
+            audience,
+            jwksUri: this.config.oauth.jwksUri,
+            clockTolerance: this.config.oauth.clockTolerance
+        });
+    }
+}
+
+/**
+ * Create a new MCP server instance
+ */
+export function createServer(config: Partial<McpServerConfig> = {}): McpServer {
+    return new McpServer(config);
+}
+
+/**
+ * Parse database configuration from connection string
+ */
+export function parseMySQLConnectionString(connectionString: string): DatabaseConfig {
+    // Parse mysql://user:password@host:port/database
+    const url = new URL(connectionString);
+
+    return {
+        type: 'mysql',
+        host: url.hostname,
+        port: parseInt(url.port, 10) || 3306,
+        username: decodeURIComponent(url.username),
+        password: decodeURIComponent(url.password),
+        database: url.pathname.slice(1), // Remove leading /
+        options: Object.fromEntries(url.searchParams)
+    };
+}