@neverinfamous/mysql-mcp 2.1.0

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

@@ -0,0 +1,58 @@
+
+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>;
+
+    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);
+
+        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([]));
+
+        const resource = createStatusResource(mockAdapter as unknown as MySQLAdapter);
+        const result = await resource.handler('mysql://status', mockContext);
+
+        expect(result).toEqual({ status: {} });
+    });
+
+    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);
+
+        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');
+    });
+});

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

@@ -0,0 +1,62 @@
+
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { createSysSchemaResource } from '../sysschema.js';
+import type { MySQLAdapter } from '../../MySQLAdapter.js';
+import { createMockMySQLAdapter, createMockRequestContext, createMockQueryResult } from '../../../../__tests__/mocks/index.js';
+
+describe('SysSchema Resource', () => {
+    let mockAdapter: ReturnType<typeof createMockMySQLAdapter>;
+    let mockContext: ReturnType<typeof createMockRequestContext>;
+
+    beforeEach(() => {
+        vi.clearAllMocks();
+        mockAdapter = createMockMySQLAdapter();
+        mockContext = createMockRequestContext();
+    });
+
+    it('should return sys schema diagnostics when available', async () => {
+        // Mock top users query
+        mockAdapter.executeQuery.mockResolvedValueOnce(createMockQueryResult([
+            { user: 'root', total_connections: 100, current_connections: 5, memory_bytes: 1000000 }
+        ]));
+        // Mock slow statements query
+        mockAdapter.executeQuery.mockResolvedValueOnce(createMockQueryResult([
+            { query_preview: 'SELECT * FROM large_table', exec_count: 50, total_latency: '5s' }
+        ]));
+        // Mock lock waits query
+        mockAdapter.executeQuery.mockResolvedValueOnce(createMockQueryResult([
+            { lock_wait_count: 0 }
+        ]));
+
+        const resource = createSysSchemaResource(mockAdapter as unknown as MySQLAdapter);
+        const result = await resource.handler('mysql://sysschema', mockContext) as { available: boolean; topUsers: unknown[] };
+
+        expect(result).toHaveProperty('available', true);
+        expect(result).toHaveProperty('topUsers');
+        expect(result).toHaveProperty('slowStatements');
+        expect(result).toHaveProperty('currentLockWaits', 0);
+    });
+
+    it('should handle sys schema not available', async () => {
+        mockAdapter.executeQuery.mockRejectedValueOnce(new Error('sys schema not found'));
+
+        const resource = createSysSchemaResource(mockAdapter as unknown as MySQLAdapter);
+        const result = await resource.handler('mysql://sysschema', mockContext) as { available: boolean; message: string };
+
+        expect(result.available).toBe(false);
+        expect(result).toHaveProperty('message');
+    });
+
+    it('should handle null query results', async () => {
+        mockAdapter.executeQuery.mockResolvedValueOnce(createMockQueryResult(null as any)); // Users
+        mockAdapter.executeQuery.mockResolvedValueOnce(createMockQueryResult(null as any)); // Statements
+        mockAdapter.executeQuery.mockResolvedValueOnce(createMockQueryResult(null as any)); // Locks
+
+        const resource = createSysSchemaResource(mockAdapter as unknown as MySQLAdapter);
+        const result = await resource.handler('mysql://sysschema', mockContext) as any;
+
+        expect(result.topUsers).toEqual([]);
+        expect(result.slowStatements).toEqual([]);
+        expect(result.currentLockWaits).toBe(0);
+    });
+});

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

@@ -0,0 +1,37 @@
+
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { createTablesResource } from '../tables.js';
+import type { MySQLAdapter } from '../../MySQLAdapter.js';
+import { createMockMySQLAdapter, createMockRequestContext } from '../../../../__tests__/mocks/index.js';
+
+interface TablesResult {
+    tables: unknown[];
+    count: number;
+}
+
+describe('Tables Resource', () => {
+    let mockAdapter: ReturnType<typeof createMockMySQLAdapter>;
+    let mockContext: ReturnType<typeof createMockRequestContext>;
+
+    beforeEach(() => {
+        vi.clearAllMocks();
+        mockAdapter = createMockMySQLAdapter();
+        mockContext = createMockRequestContext();
+    });
+
+    it('should call listTables adapter method', async () => {
+        const resource = createTablesResource(mockAdapter as unknown as MySQLAdapter);
+        await resource.handler('mysql://tables', mockContext);
+
+        expect(mockAdapter.listTables).toHaveBeenCalled();
+    });
+
+    it('should return table list with count', async () => {
+        const resource = createTablesResource(mockAdapter as unknown as MySQLAdapter);
+        const result = await resource.handler('mysql://tables', mockContext) as TablesResult;
+
+        expect(result).toHaveProperty('tables');
+        expect(result).toHaveProperty('count');
+        expect(Array.isArray(result.tables)).toBe(true);
+    });
+});

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

@@ -0,0 +1,70 @@
+/**
+ * mysql-mcp - Variables Resource Unit Tests
+ * 
+ * Tests for variables resource handler execution.
+ */
+
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { createMockMySQLAdapter, createMockQueryResult, createMockRequestContext } from '../../../../__tests__/mocks/index.js';
+import type { MySQLAdapter } from '../../MySQLAdapter.js';
+import { createVariablesResource } from '../variables.js';
+
+describe('Variables Resource', () => {
+    let mockAdapter: ReturnType<typeof createMockMySQLAdapter>;
+    let mockContext: ReturnType<typeof createMockRequestContext>;
+
+    beforeEach(() => {
+        vi.clearAllMocks();
+        mockAdapter = createMockMySQLAdapter();
+        mockContext = createMockRequestContext();
+    });
+
+    it('should return all global variables', async () => {
+        mockAdapter.executeQuery.mockResolvedValueOnce(createMockQueryResult([
+            { Variable_name: 'max_connections', Value: '151' },
+            { Variable_name: 'innodb_buffer_pool_size', Value: '134217728' }
+        ]));
+
+        const resource = createVariablesResource(mockAdapter as unknown as MySQLAdapter);
+        const result = await resource.handler('mysql://variables', mockContext) as { variables: Record<string, string> };
+
+        expect(result.variables).toEqual({
+            max_connections: '151',
+            innodb_buffer_pool_size: '134217728'
+        });
+        expect(mockAdapter.executeQuery).toHaveBeenCalledWith('SHOW GLOBAL VARIABLES');
+    });
+
+    it('should handle empty result set', async () => {
+        mockAdapter.executeQuery.mockResolvedValueOnce(createMockQueryResult([]));
+
+        const resource = createVariablesResource(mockAdapter as unknown as MySQLAdapter);
+        const result = await resource.handler('mysql://variables', mockContext) as { variables: Record<string, string> };
+
+        expect(result.variables).toEqual({});
+    });
+
+    it('should handle missing rows property in result', async () => {
+        mockAdapter.executeQuery.mockResolvedValueOnce({
+            columns: [],
+            rowsAffected: 0,
+            insertId: undefined,
+            start_time: 0,
+            executionTimeMs: 0
+        });
+
+        const resource = createVariablesResource(mockAdapter as unknown as MySQLAdapter);
+        const result = await resource.handler('mysql://variables', mockContext) as { variables: Record<string, string> };
+
+        expect(result.variables).toEqual({});
+    });
+
+    it('should handle database errors', async () => {
+        mockAdapter.executeQuery.mockRejectedValueOnce(new Error('Connection failed'));
+
+        const resource = createVariablesResource(mockAdapter as unknown as MySQLAdapter);
+        
+        await expect(resource.handler('mysql://variables', mockContext))
+            .rejects.toThrow('Connection failed');
+    });
+});

package/src/adapters/mysql/resources/capabilities.ts

@@ -0,0 +1,51 @@
+/**
+ * MySQL Resource - Capabilities
+ * 
+ * Provides server version, available features, and tool categories.
+ */
+import type { MySQLAdapter } from '../MySQLAdapter.js';
+import type { ResourceDefinition, RequestContext } from '../../../types/index.js';
+import { TOOL_GROUPS, META_GROUPS, getMetaGroupInfo, getToolGroupInfo } from '../../../filtering/ToolFilter.js';
+
+export function createCapabilitiesResource(adapter: MySQLAdapter): ResourceDefinition {
+    return {
+        uri: 'mysql://capabilities',
+        name: 'Server Capabilities',
+        title: 'MySQL Server Capabilities',
+        description: 'MySQL server version, extensions, and available tool categories',
+        mimeType: 'application/json',
+        annotations: {
+            audience: ['user', 'assistant'],
+            priority: 0.9
+        },
+        handler: async (_uri: string, _context: RequestContext) => {
+            // Get server version
+            const versionResult = await adapter.executeQuery('SELECT VERSION() as version');
+            const version = (versionResult.rows?.[0]?.['version'] as string) ?? 'unknown';
+
+            // Get available features
+            const features = {
+                json: version.startsWith('5.7') || version.startsWith('8.'),
+                fulltext: true,
+                partitioning: true,
+                replication: true,
+                gtid: version.startsWith('5.6') || version.startsWith('5.7') || version.startsWith('8.')
+            };
+
+            // Get tool groups and meta-groups info
+            const toolGroupList = getToolGroupInfo();
+            const metaGroupList = getMetaGroupInfo();
+
+            return {
+                server: {
+                    version,
+                    features
+                },
+                toolCategoryCount: Object.keys(TOOL_GROUPS).length,
+                metaGroupCount: Object.keys(META_GROUPS).length,
+                toolGroups: toolGroupList,
+                metaGroups: metaGroupList
+            };
+        }
+    };
+}

package/src/adapters/mysql/resources/cluster.ts

@@ -0,0 +1,71 @@
+/**
+ * MySQL Resource - Cluster
+ */
+import type { MySQLAdapter } from '../MySQLAdapter.js';
+import type { ResourceDefinition, RequestContext } from '../../../types/index.js';
+
+export function createClusterResource(adapter: MySQLAdapter): ResourceDefinition {
+    return {
+        uri: 'mysql://cluster',
+        name: 'Cluster Status',
+        title: 'MySQL Group Replication / InnoDB Cluster',
+        description: 'Group Replication and InnoDB Cluster status overview',
+        mimeType: 'application/json',
+        annotations: {
+            audience: ['user', 'assistant'],
+            priority: 0.7
+        },
+        handler: async (_uri: string, _context: RequestContext) => {
+            try {
+                // Check if Group Replication is enabled
+                const grStatusResult = await adapter.executeQuery(
+                    "SHOW VARIABLES LIKE 'group_replication_group_name'"
+                );
+                const grRow = grStatusResult.rows?.[0];
+                const groupNameVal = grRow?.['Value'];
+                const groupName = typeof groupNameVal === 'string' ? groupNameVal : null;
+
+                if (groupName === null || groupName === '') {
+                    return {
+                        groupReplicationEnabled: false,
+                        message: 'Group Replication is not configured'
+                    };
+                }
+
+                // Get members
+                const membersResult = await adapter.executeQuery(`
+                    SELECT 
+                        MEMBER_ID as id,
+                        MEMBER_HOST as host,
+                        MEMBER_PORT as port,
+                        MEMBER_STATE as state,
+                        MEMBER_ROLE as role,
+                        MEMBER_VERSION as version
+                    FROM performance_schema.replication_group_members
+                `);
+
+                // Get primary
+                const primaryResult = await adapter.executeQuery(`
+                    SELECT MEMBER_HOST as host, MEMBER_PORT as port
+                    FROM performance_schema.replication_group_members
+                    WHERE MEMBER_ROLE = 'PRIMARY'
+                `);
+                const primaryRow = primaryResult.rows?.[0];
+
+                return {
+                    groupReplicationEnabled: true,
+                    groupName,
+                    memberCount: membersResult.rows?.length ?? 0,
+                    members: membersResult.rows ?? [],
+                    primary: primaryRow ? `${String(primaryRow['host'])}:${String(primaryRow['port'])}` : null
+                };
+            } catch {
+                return {
+                    groupReplicationEnabled: false,
+                    message: 'Unable to retrieve cluster information',
+                    suggestion: 'Group Replication may not be configured or insufficient privileges'
+                };
+            }
+        }
+    };
+}

package/src/adapters/mysql/resources/docstore.ts

@@ -0,0 +1,69 @@
+/**
+ * MySQL Resource - Document Store
+ */
+import type { MySQLAdapter } from '../MySQLAdapter.js';
+import type { ResourceDefinition, RequestContext } from '../../../types/index.js';
+
+export function createDocstoreResource(adapter: MySQLAdapter): ResourceDefinition {
+    return {
+        uri: 'mysql://docstore',
+        name: 'Document Store Collections',
+        title: 'MySQL Document Store',
+        description: 'X DevAPI document collections in the current database',
+        mimeType: 'application/json',
+        annotations: {
+            audience: ['user', 'assistant'],
+            priority: 0.5
+        },
+        handler: async (_uri: string, _context: RequestContext) => {
+            try {
+                // Check if X Plugin is enabled
+                const pluginResult = await adapter.executeQuery(
+                    "SELECT PLUGIN_STATUS FROM information_schema.PLUGINS WHERE PLUGIN_NAME = 'mysqlx'"
+                );
+                const pluginRow = pluginResult.rows?.[0];
+                const xPluginEnabled = pluginRow?.['PLUGIN_STATUS'] === 'ACTIVE';
+
+                // Get collections (tables with _id column and doc JSON column)
+                const collectionsResult = await adapter.executeQuery(`
+                    SELECT 
+                        t.TABLE_NAME as collection_name,
+                        t.TABLE_ROWS as row_count,
+                        t.DATA_LENGTH + t.INDEX_LENGTH as size_bytes
+                    FROM information_schema.TABLES t
+                    WHERE t.TABLE_SCHEMA = DATABASE()
+                      AND EXISTS (
+                          SELECT 1 FROM information_schema.COLUMNS c
+                          WHERE c.TABLE_SCHEMA = t.TABLE_SCHEMA
+                            AND c.TABLE_NAME = t.TABLE_NAME
+                            AND c.COLUMN_NAME = 'doc'
+                            AND c.DATA_TYPE = 'json'
+                      )
+                      AND EXISTS (
+                          SELECT 1 FROM information_schema.COLUMNS c2
+                          WHERE c2.TABLE_SCHEMA = t.TABLE_SCHEMA
+                            AND c2.TABLE_NAME = t.TABLE_NAME
+                            AND c2.COLUMN_NAME = '_id'
+                      )
+                    ORDER BY t.TABLE_NAME
+                `);
+
+                return {
+                    xPluginEnabled,
+                    collectionCount: collectionsResult.rows?.length ?? 0,
+                    collections: collectionsResult.rows ?? [],
+                    note: xPluginEnabled
+                        ? 'X Plugin is active - X Protocol available on port 33060'
+                        : 'X Plugin not active - document store limited to SQL access'
+                };
+            } catch {
+                return {
+                    xPluginEnabled: false,
+                    collectionCount: 0,
+                    collections: [],
+                    error: 'Unable to retrieve document store information'
+                };
+            }
+        }
+    };
+}

package/src/adapters/mysql/resources/events.ts

@@ -0,0 +1,50 @@
+/**
+ * MySQL Resource - Events
+ */
+import type { MySQLAdapter } from '../MySQLAdapter.js';
+import type { ResourceDefinition, RequestContext } from '../../../types/index.js';
+
+export function createEventsResource(adapter: MySQLAdapter): ResourceDefinition {
+    return {
+        uri: 'mysql://events',
+        name: 'Scheduled Events',
+        title: 'MySQL Scheduled Events',
+        description: 'Event Scheduler status and scheduled events overview',
+        mimeType: 'application/json',
+        annotations: {
+            audience: ['user', 'assistant'],
+            priority: 0.6
+        },
+        handler: async (_uri: string, _context: RequestContext) => {
+            // Get scheduler status
+            const schedulerResult = await adapter.executeQuery(
+                "SHOW VARIABLES LIKE 'event_scheduler'"
+            );
+            const schedulerRow = schedulerResult.rows?.[0];
+            const schedulerVal = schedulerRow?.['Value'];
+            const schedulerStatus = typeof schedulerVal === 'string' ? schedulerVal : 'OFF';
+
+            // Get all events
+            const eventsResult = await adapter.executeQuery(`
+                SELECT 
+                    EVENT_SCHEMA as schema_name,
+                    EVENT_NAME as name,
+                    EVENT_TYPE as type,
+                    STATUS as status,
+                    EXECUTE_AT as execute_at,
+                    INTERVAL_VALUE as interval_value,
+                    INTERVAL_FIELD as interval_field,
+                    LAST_EXECUTED as last_executed
+                FROM information_schema.EVENTS
+                ORDER BY EVENT_SCHEMA, EVENT_NAME
+            `);
+
+            return {
+                schedulerEnabled: schedulerStatus === 'ON',
+                schedulerStatus,
+                eventCount: eventsResult.rows?.length ?? 0,
+                events: eventsResult.rows ?? []
+            };
+        }
+    };
+}

package/src/adapters/mysql/resources/health.ts

@@ -0,0 +1,96 @@
+/**
+ * MySQL Resource - Health
+ * 
+ * Comprehensive database health status including connection pool,
+ * thread activity, and InnoDB status.
+ */
+import type { MySQLAdapter } from '../MySQLAdapter.js';
+import type { ResourceDefinition, RequestContext } from '../../../types/index.js';
+
+export function createHealthResource(adapter: MySQLAdapter): ResourceDefinition {
+    return {
+        uri: 'mysql://health',
+        name: 'Database Health',
+        title: 'MySQL Database Health',
+        description: 'Comprehensive database health status',
+        mimeType: 'application/json',
+        annotations: {
+            audience: ['user', 'assistant'],
+            priority: 1.0
+        },
+        handler: async (_uri: string, _context: RequestContext) => {
+            // Execute health queries in parallel for better performance
+            const [statusResult, maxConnResult] = await Promise.all([
+                // Get uptime and connection info
+                adapter.executeQuery(`
+                    SHOW GLOBAL STATUS WHERE Variable_name IN (
+                        'Uptime', 'Threads_connected', 'Threads_running', 
+                        'Max_used_connections', 'Connections', 'Aborted_connects',
+                        'Slow_queries', 'Questions', 'Com_select', 'Com_insert',
+                        'Com_update', 'Com_delete', 'Innodb_buffer_pool_read_requests',
+                        'Innodb_buffer_pool_reads', 'Table_locks_waited', 'Table_locks_immediate'
+                    )
+                `),
+                // Get max_connections for percentage calculation
+                adapter.executeQuery(
+                    "SHOW GLOBAL VARIABLES LIKE 'max_connections'"
+                )
+            ]);
+
+            const status: Record<string, string> = {};
+            for (const row of statusResult.rows ?? []) {
+                status[row['Variable_name'] as string] = row['Value'] as string;
+            }
+
+            const maxConnections = parseInt(
+                (maxConnResult.rows?.[0]?.['Value'] as string) ?? '151',
+                10
+            );
+
+            // Calculate health metrics
+            const threadsConnected = parseInt(status['Threads_connected'] ?? '0', 10);
+            const connectionUsagePercent = Math.round((threadsConnected / maxConnections) * 100);
+
+            const bufferPoolRequests = parseInt(status['Innodb_buffer_pool_read_requests'] ?? '0', 10);
+            const bufferPoolReads = parseInt(status['Innodb_buffer_pool_reads'] ?? '0', 10);
+            const bufferPoolHitRatio = bufferPoolRequests > 0
+                ? Math.round(((bufferPoolRequests - bufferPoolReads) / bufferPoolRequests) * 100 * 100) / 100
+                : 100;
+
+            const tableLockWaited = parseInt(status['Table_locks_waited'] ?? '0', 10);
+            const tableLockImmediate = parseInt(status['Table_locks_immediate'] ?? '0', 10);
+            const tableLockContention = (tableLockWaited + tableLockImmediate) > 0
+                ? Math.round((tableLockWaited / (tableLockWaited + tableLockImmediate)) * 100 * 100) / 100
+                : 0;
+
+            // Get connection pool stats if available
+            const pool = adapter.getPool();
+            const poolStats = pool?.getStats();
+
+            return {
+                status: 'healthy',
+                uptime_seconds: parseInt(status['Uptime'] ?? '0', 10),
+                connections: {
+                    current: threadsConnected,
+                    running: parseInt(status['Threads_running'] ?? '0', 10),
+                    max_used: parseInt(status['Max_used_connections'] ?? '0', 10),
+                    max_allowed: maxConnections,
+                    usage_percent: connectionUsagePercent
+                },
+                performance: {
+                    questions: parseInt(status['Questions'] ?? '0', 10),
+                    slow_queries: parseInt(status['Slow_queries'] ?? '0', 10),
+                    buffer_pool_hit_ratio: bufferPoolHitRatio,
+                    table_lock_contention_percent: tableLockContention
+                },
+                queries: {
+                    select: parseInt(status['Com_select'] ?? '0', 10),
+                    insert: parseInt(status['Com_insert'] ?? '0', 10),
+                    update: parseInt(status['Com_update'] ?? '0', 10),
+                    delete: parseInt(status['Com_delete'] ?? '0', 10)
+                },
+                pool: poolStats ?? null
+            };
+        }
+    };
+}

package/src/adapters/mysql/resources/index.ts

@@ -0,0 +1,77 @@
+/**
+ * MySQL MCP Resources
+ * 
+ * Provides structured data access via URI patterns.
+ * 18 resources total.
+ */
+import type { MySQLAdapter } from '../MySQLAdapter.js';
+import type { ResourceDefinition } from '../../../types/index.js';
+
+// Core resources
+import { createSchemaResource } from './schema.js';
+import { createTablesResource } from './tables.js';
+import { createVariablesResource } from './variables.js';
+import { createStatusResource } from './status.js';
+import { createProcesslistResource } from './processlist.js';
+import { createPoolResource } from './pool.js';
+
+// Extended monitoring resources
+import { createCapabilitiesResource } from './capabilities.js';
+import { createHealthResource } from './health.js';
+import { createPerformanceResource } from './performance.js';
+import { createIndexesResource } from './indexes.js';
+import { createReplicationResource } from './replication.js';
+import { createInnodbResource } from './innodb.js';
+
+// New resources (6)
+import { createEventsResource } from './events.js';
+import { createSysSchemaResource } from './sysschema.js';
+import { createLocksResource } from './locks.js';
+import { createClusterResource } from './cluster.js';
+import { createSpatialResource } from './spatial.js';
+import { createDocstoreResource } from './docstore.js';
+
+/**
+ * Get all MySQL resources (12 total)
+ * 
+ * Core (6):
+ * - mysql://schema - Full database schema
+ * - mysql://tables - Table listing with metadata
+ * - mysql://variables - Server configuration variables
+ * - mysql://status - Server status metrics
+ * - mysql://processlist - Active connections and queries
+ * - mysql://pool - Connection pool statistics
+ * 
+ * Extended Monitoring (6):
+ * - mysql://capabilities - Server version, features, tool categories
+ * - mysql://health - Comprehensive database health status
+ * - mysql://performance - Query performance metrics
+ * - mysql://indexes - Index usage and statistics
+ * - mysql://replication - Replication status and lag
+ * - mysql://innodb - InnoDB buffer pool and engine metrics
+ */
+export function getMySQLResources(adapter: MySQLAdapter): ResourceDefinition[] {
+    return [
+        // Core resources
+        createSchemaResource(adapter),
+        createTablesResource(adapter),
+        createVariablesResource(adapter),
+        createStatusResource(adapter),
+        createProcesslistResource(adapter),
+        createPoolResource(adapter),
+        // Extended monitoring resources
+        createCapabilitiesResource(adapter),
+        createHealthResource(adapter),
+        createPerformanceResource(adapter),
+        createIndexesResource(adapter),
+        createReplicationResource(adapter),
+        createInnodbResource(adapter),
+        // New resources (6)
+        createEventsResource(adapter),
+        createSysSchemaResource(adapter),
+        createLocksResource(adapter),
+        createClusterResource(adapter),
+        createSpatialResource(adapter),
+        createDocstoreResource(adapter)
+    ];
+}