@neverinfamous/mysql-mcp 2.1.0

package/src/adapters/mysql/tools/sysschema/resources.ts

@@ -0,0 +1,232 @@
+/**
+ * MySQL sys Schema Tools - Resource Monitoring
+ * 
+ * Tools for monitoring database resources and objects.
+ * 3 tools: schema_stats, innodb_lock_waits, memory_summary.
+ */
+
+import { z } from 'zod';
+import type { MySQLAdapter } from '../../MySQLAdapter.js';
+import type { ToolDefinition, RequestContext } from '../../../../types/index.js';
+
+// =============================================================================
+// Zod Schemas
+// =============================================================================
+
+const LimitSchema = z.object({
+    limit: z.number().default(20).describe('Maximum number of results to return')
+});
+
+/**
+ * Get schema object statistics
+ */
+export function createSysSchemaStatsTool(adapter: MySQLAdapter): ToolDefinition {
+    return {
+        name: 'mysql_sys_schema_stats',
+        title: 'MySQL Schema Statistics',
+        description: 'Get aggregated statistics for a schema including tables, indexes, and auto-increment status.',
+        group: 'sysschema',
+        inputSchema: z.object({
+            schema: z.string().optional().describe('Schema name (defaults to current database)'),
+            limit: z.number().default(50).describe('Maximum number of results')
+        }),
+        requiredScopes: ['read'],
+        annotations: {
+            readOnlyHint: true,
+            idempotentHint: true
+        },
+        handler: async (params: unknown, _context: RequestContext) => {
+            const { schema, limit } = z.object({
+                schema: z.string().optional(),
+                limit: z.number().default(50)
+            }).parse(params);
+
+            // Get table statistics
+            const tableStatsQuery = `
+                SELECT 
+                    table_schema,
+                    table_name,
+                    rows_fetched,
+                    fetch_latency,
+                    rows_inserted,
+                    insert_latency,
+                    rows_updated,
+                    update_latency,
+                    rows_deleted,
+                    delete_latency,
+                    io_read_requests,
+                    io_read,
+                    io_read_latency,
+                    io_write_requests,
+                    io_write,
+                    io_write_latency
+                FROM sys.schema_table_statistics
+                WHERE table_schema = COALESCE(?, DATABASE())
+                ORDER BY (fetch_latency + insert_latency + update_latency + delete_latency) DESC
+                LIMIT ${String(limit)}
+            `;
+
+            // Get index statistics
+            const indexStatsQuery = `
+                SELECT 
+                    table_schema,
+                    table_name,
+                    index_name,
+                    rows_selected,
+                    select_latency,
+                    rows_inserted,
+                    insert_latency,
+                    rows_updated,
+                    update_latency,
+                    rows_deleted,
+                    delete_latency
+                FROM sys.schema_index_statistics
+                WHERE table_schema = COALESCE(?, DATABASE())
+                ORDER BY (select_latency + insert_latency + update_latency + delete_latency) DESC
+                LIMIT ${String(limit)}
+            `;
+
+            // Get auto-increment status
+            const autoIncQuery = `
+                SELECT 
+                    table_schema,
+                    table_name,
+                    column_name,
+                    data_type,
+                    column_type,
+                    auto_increment_ratio
+                FROM sys.schema_auto_increment_columns
+                WHERE table_schema = COALESCE(?, DATABASE())
+                ORDER BY auto_increment_ratio DESC
+                LIMIT ${String(limit)}
+            `;
+
+            const [tableStats, indexStats, autoIncStats] = await Promise.all([
+                adapter.executeQuery(tableStatsQuery, [schema ?? null]),
+                adapter.executeQuery(indexStatsQuery, [schema ?? null]),
+                adapter.executeQuery(autoIncQuery, [schema ?? null])
+            ]);
+
+            return {
+                tableStatistics: tableStats.rows ?? [],
+                indexStatistics: indexStats.rows ?? [],
+                autoIncrementStatus: autoIncStats.rows ?? [],
+                schemaName: schema ?? 'current'
+            };
+        }
+    };
+}
+
+/**
+ * Get InnoDB lock waits
+ */
+export function createSysInnoDBLockWaitsTool(adapter: MySQLAdapter): ToolDefinition {
+    return {
+        name: 'mysql_sys_innodb_lock_waits',
+        title: 'MySQL InnoDB Lock Waits',
+        description: 'Get current InnoDB lock contention information from sys schema.',
+        group: 'sysschema',
+        inputSchema: LimitSchema,
+        requiredScopes: ['read'],
+        annotations: {
+            readOnlyHint: true,
+            idempotentHint: true
+        },
+        handler: async (params: unknown, _context: RequestContext) => {
+            const { limit } = LimitSchema.parse(params);
+
+            const query = `
+                SELECT 
+                    wait_started,
+                    wait_age,
+                    locked_table,
+                    locked_index,
+                    locked_type,
+                    waiting_trx_id,
+                    waiting_trx_started,
+                    waiting_trx_age,
+                    waiting_trx_rows_locked,
+                    waiting_trx_rows_modified,
+                    waiting_query,
+                    waiting_lock_mode,
+                    blocking_trx_id,
+                    blocking_trx_started,
+                    blocking_trx_age,
+                    blocking_trx_rows_locked,
+                    blocking_trx_rows_modified,
+                    blocking_query,
+                    blocking_lock_mode
+                FROM sys.innodb_lock_waits
+                ORDER BY wait_started
+                LIMIT ${String(limit)}
+            `;
+
+            const result = await adapter.executeQuery(query);
+            return {
+                lockWaits: result.rows,
+                count: result.rows?.length ?? 0,
+                hasContention: (result.rows?.length ?? 0) > 0
+            };
+        }
+    };
+}
+
+/**
+ * Get memory usage summary
+ */
+export function createSysMemorySummaryTool(adapter: MySQLAdapter): ToolDefinition {
+    return {
+        name: 'mysql_sys_memory_summary',
+        title: 'MySQL Memory Summary',
+        description: 'Get memory usage summary by allocation type from sys schema.',
+        group: 'sysschema',
+        inputSchema: LimitSchema,
+        requiredScopes: ['read'],
+        annotations: {
+            readOnlyHint: true,
+            idempotentHint: true
+        },
+        handler: async (params: unknown, _context: RequestContext) => {
+            const { limit } = LimitSchema.parse(params);
+
+            // Global memory summary
+            const globalQuery = `
+                SELECT 
+                    event_name,
+                    current_count,
+                    current_alloc,
+                    current_avg_alloc,
+                    high_count,
+                    high_alloc,
+                    high_avg_alloc
+                FROM sys.memory_global_by_current_bytes
+                ORDER BY current_alloc DESC
+                LIMIT ${String(limit)}
+            `;
+
+            // Memory by user
+            const userQuery = `
+                SELECT 
+                    user,
+                    current_count_used,
+                    current_allocated,
+                    current_avg_alloc,
+                    current_max_alloc,
+                    total_allocated
+                FROM sys.memory_by_user_by_current_bytes
+                ORDER BY current_allocated DESC
+                LIMIT ${String(limit)}
+            `;
+
+            const [globalStats, userStats] = await Promise.all([
+                adapter.executeQuery(globalQuery),
+                adapter.executeQuery(userQuery)
+            ]);
+
+            return {
+                globalMemory: globalStats.rows ?? [],
+                memoryByUser: userStats.rows ?? []
+            };
+        }
+    };
+}

package/src/adapters/mysql/tools/text/__tests__/fulltext.test.ts

@@ -0,0 +1,153 @@
+/**
+ * mysql-mcp - Text Fulltext Tools Unit Tests
+ * 
+ * Comprehensive tests for fulltext.ts module functions.
+ */
+
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import {
+    createFulltextCreateTool,
+    createFulltextSearchTool,
+    createFulltextBooleanTool,
+    createFulltextExpandTool
+} from '../fulltext.js';
+import type { MySQLAdapter } from '../../MySQLAdapter.js';
+import { createMockMySQLAdapter, createMockRequestContext, createMockQueryResult } from '../../../../../__tests__/mocks/index.js';
+
+describe('Text Fulltext Tools', () => {
+    let mockAdapter: ReturnType<typeof createMockMySQLAdapter>;
+    let mockContext: ReturnType<typeof createMockRequestContext>;
+
+    beforeEach(() => {
+        vi.clearAllMocks();
+        mockAdapter = createMockMySQLAdapter();
+        mockContext = createMockRequestContext();
+    });
+
+    describe('createFulltextCreateTool', () => {
+        it('should create tool with correct definition', () => {
+            const tool = createFulltextCreateTool(mockAdapter as unknown as MySQLAdapter);
+            expect(tool.name).toBe('mysql_fulltext_create');
+        });
+
+        it('should create fulltext index', async () => {
+            const tool = createFulltextCreateTool(mockAdapter as unknown as MySQLAdapter);
+            const result = await tool.handler({
+                table: 'articles',
+                columns: ['title', 'content'],
+                indexName: 'ft_idx'
+            }, mockContext) as { indexName: string };
+
+            expect(mockAdapter.executeQuery).toHaveBeenCalled();
+            const call = mockAdapter.executeQuery.mock.calls[0][0] as string;
+            expect(call).toContain('CREATE FULLTEXT INDEX `ft_idx` ON `articles` (`title`, `content`)');
+            expect(result.indexName).toBe('ft_idx');
+        });
+
+        it('should generate index name if not provided', async () => {
+            const tool = createFulltextCreateTool(mockAdapter as unknown as MySQLAdapter);
+            const result = await tool.handler({
+                table: 'articles',
+                columns: ['title', 'content']
+            }, mockContext) as { indexName: string };
+
+            expect(mockAdapter.executeQuery).toHaveBeenCalled();
+            const call = mockAdapter.executeQuery.mock.calls[0][0] as string;
+            expect(call).toContain('CREATE FULLTEXT INDEX `ft_articles_title_content`');
+            expect(result.indexName).toBe('ft_articles_title_content');
+        });
+    });
+
+    describe('createFulltextSearchTool', () => {
+        it('should create tool with correct definition', () => {
+            const tool = createFulltextSearchTool(mockAdapter as unknown as MySQLAdapter);
+            expect(tool.name).toBe('mysql_fulltext_search');
+        });
+
+        it('should search in natural language mode by default', async () => {
+            mockAdapter.executeReadQuery.mockResolvedValue(createMockQueryResult([{ id: 1 }]));
+
+            const tool = createFulltextSearchTool(mockAdapter as unknown as MySQLAdapter);
+            await tool.handler({
+                table: 'articles',
+                columns: ['title', 'content'],
+                query: 'database'
+            }, mockContext);
+
+            const call = mockAdapter.executeReadQuery.mock.calls[0][0] as string;
+            expect(call).toContain('MATCH(`title`, `content`) AGAINST(? IN NATURAL LANGUAGE MODE)');
+        });
+
+        it('should search in boolean mode', async () => {
+            mockAdapter.executeReadQuery.mockResolvedValue(createMockQueryResult([]));
+
+            const tool = createFulltextSearchTool(mockAdapter as unknown as MySQLAdapter);
+            await tool.handler({
+                table: 'articles',
+                columns: ['title'],
+                query: '+mysql -oracle',
+                mode: 'BOOLEAN'
+            }, mockContext);
+
+            const call = mockAdapter.executeReadQuery.mock.calls[0][0] as string;
+            expect(call).toContain('MATCH(`title`) AGAINST(? IN BOOLEAN MODE)');
+        });
+
+        it('should search with query expansion', async () => {
+            mockAdapter.executeReadQuery.mockResolvedValue(createMockQueryResult([]));
+
+            const tool = createFulltextSearchTool(mockAdapter as unknown as MySQLAdapter);
+            await tool.handler({
+                table: 'articles',
+                columns: ['title'],
+                query: 'database',
+                mode: 'EXPANSION'
+            }, mockContext);
+
+            const call = mockAdapter.executeReadQuery.mock.calls[0][0] as string;
+            expect(call).toContain('MATCH(`title`) AGAINST(? WITH QUERY EXPANSION)');
+        });
+    });
+
+    describe('createFulltextBooleanTool', () => {
+        it('should create tool with correct definition', () => {
+            const tool = createFulltextBooleanTool(mockAdapter as unknown as MySQLAdapter);
+            expect(tool.name).toBe('mysql_fulltext_boolean');
+        });
+
+        it('should search in boolean mode', async () => {
+            mockAdapter.executeReadQuery.mockResolvedValue(createMockQueryResult([]));
+
+            const tool = createFulltextBooleanTool(mockAdapter as unknown as MySQLAdapter);
+            await tool.handler({
+                table: 'articles',
+                columns: ['title'],
+                query: '+mysql'
+            }, mockContext);
+
+            const call = mockAdapter.executeReadQuery.mock.calls[0][0] as string;
+            expect(call).toContain('MATCH(`title`) AGAINST(? IN BOOLEAN MODE)');
+        });
+    });
+
+    describe('createFulltextExpandTool', () => {
+        it('should create tool with correct definition', () => {
+            const tool = createFulltextExpandTool(mockAdapter as unknown as MySQLAdapter);
+            expect(tool.name).toBe('mysql_fulltext_expand');
+        });
+
+        it('should search with query expansion', async () => {
+            mockAdapter.executeReadQuery.mockResolvedValue(createMockQueryResult([]));
+
+            const tool = createFulltextExpandTool(mockAdapter as unknown as MySQLAdapter);
+            await tool.handler({
+                table: 'articles',
+                columns: ['title'],
+                query: 'database'
+            }, mockContext);
+
+            const call = mockAdapter.executeReadQuery.mock.calls[0][0] as string;
+            expect(call).toContain('MATCH(`title`) AGAINST(? WITH QUERY EXPANSION)');
+        });
+    });
+});

package/src/adapters/mysql/tools/text/__tests__/processing.test.ts

@@ -0,0 +1,201 @@
+/**
+ * mysql-mcp - Text Processing Tools Unit Tests
+ * 
+ * Comprehensive tests for processing.ts module functions.
+ */
+
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import {
+    createRegexpMatchTool,
+    createLikeSearchTool,
+    createSoundexTool,
+    createSubstringTool,
+    createConcatTool,
+    createCollationConvertTool
+} from '../processing.js';
+import type { MySQLAdapter } from '../../MySQLAdapter.js';
+import { createMockMySQLAdapter, createMockRequestContext, createMockQueryResult } from '../../../../../__tests__/mocks/index.js';
+
+describe('Text Processing Tools', () => {
+    let mockAdapter: ReturnType<typeof createMockMySQLAdapter>;
+    let mockContext: ReturnType<typeof createMockRequestContext>;
+
+    beforeEach(() => {
+        vi.clearAllMocks();
+        mockAdapter = createMockMySQLAdapter();
+        mockContext = createMockRequestContext();
+    });
+
+    describe('createRegexpMatchTool', () => {
+        it('should perform regex match query', async () => {
+            mockAdapter.executeReadQuery.mockResolvedValue(createMockQueryResult([{ id: 1 }]));
+
+            const tool = createRegexpMatchTool(mockAdapter as unknown as MySQLAdapter);
+            const result = await tool.handler({
+                table: 'users',
+                column: 'email',
+                pattern: '^admin'
+            }, mockContext) as { rows: unknown[] };
+
+            expect(mockAdapter.executeReadQuery).toHaveBeenCalled();
+            const call = mockAdapter.executeReadQuery.mock.calls[0][0] as string;
+            expect(call).toContain('REGEXP ?');
+            expect(result.rows).toHaveLength(1);
+        });
+    });
+
+    describe('createLikeSearchTool', () => {
+        it('should perform like search query', async () => {
+            mockAdapter.executeReadQuery.mockResolvedValue(createMockQueryResult([]));
+
+            const tool = createLikeSearchTool(mockAdapter as unknown as MySQLAdapter);
+            await tool.handler({
+                table: 'users',
+                column: 'name',
+                pattern: 'John%'
+            }, mockContext);
+
+            const call = mockAdapter.executeReadQuery.mock.calls[0][0] as string;
+            expect(call).toContain('LIKE ?');
+        });
+    });
+
+    describe('createSoundexTool', () => {
+        it('should perform soundex query', async () => {
+            mockAdapter.executeReadQuery.mockResolvedValue(createMockQueryResult([]));
+
+            const tool = createSoundexTool(mockAdapter as unknown as MySQLAdapter);
+            await tool.handler({
+                table: 'users',
+                column: 'name',
+                value: 'Jon'
+            }, mockContext);
+
+            const call = mockAdapter.executeReadQuery.mock.calls[0][0] as string;
+            expect(call).toContain('SOUNDEX(`name`) = SOUNDEX(?)');
+        });
+    });
+
+    describe('createSubstringTool', () => {
+        it('should extract substring with length', async () => {
+            mockAdapter.executeReadQuery.mockResolvedValue(createMockQueryResult([{ substring_value: 'abc' }]));
+
+            const tool = createSubstringTool(mockAdapter as unknown as MySQLAdapter);
+            await tool.handler({
+                table: 'logs',
+                column: 'message',
+                start: 1,
+                length: 3
+            }, mockContext);
+
+            const call = mockAdapter.executeReadQuery.mock.calls[0][0] as string;
+            expect(call).toContain('SUBSTRING(`message`, ?, ?)');
+        });
+
+        it('should extract substring without length', async () => {
+            mockAdapter.executeReadQuery.mockResolvedValue(createMockQueryResult([]));
+
+            const tool = createSubstringTool(mockAdapter as unknown as MySQLAdapter);
+            await tool.handler({
+                table: 'logs',
+                column: 'message',
+                start: 5
+            }, mockContext);
+
+            const call = mockAdapter.executeReadQuery.mock.calls[0][0] as string;
+            expect(call).toContain('SUBSTRING(`message`, ?)');
+        });
+        it('should extract substring with where clause', async () => {
+            mockAdapter.executeReadQuery.mockResolvedValue(createMockQueryResult([]));
+
+            const tool = createSubstringTool(mockAdapter as unknown as MySQLAdapter);
+            await tool.handler({
+                table: 'logs',
+                column: 'message',
+                start: 1,
+                where: 'id > 100'
+            }, mockContext);
+
+            const call = mockAdapter.executeReadQuery.mock.calls[0][0] as string;
+            expect(call).toContain('WHERE id > 100');
+        });
+    });
+
+    describe('createConcatTool', () => {
+        it('should concatenate columns', async () => {
+            mockAdapter.executeReadQuery.mockResolvedValue(createMockQueryResult([{ full_name: 'John Doe' }]));
+
+            const tool = createConcatTool(mockAdapter as unknown as MySQLAdapter);
+            await tool.handler({
+                table: 'users',
+                columns: ['first_name', 'last_name'],
+                separator: ' ',
+                alias: 'full_name'
+            }, mockContext);
+
+            const call = mockAdapter.executeReadQuery.mock.calls[0][0] as string;
+            expect(call).toContain("CONCAT_WS(?, `first_name`, `last_name`) as `full_name`");
+        });
+
+        it('should concatenate with where clause', async () => {
+            mockAdapter.executeReadQuery.mockResolvedValue(createMockQueryResult([]));
+
+            const tool = createConcatTool(mockAdapter as unknown as MySQLAdapter);
+            await tool.handler({
+                table: 'users',
+                columns: ['first_name', 'last_name'],
+                where: 'active = 1'
+            }, mockContext);
+
+            const call = mockAdapter.executeReadQuery.mock.calls[0][0] as string;
+            expect(call).toContain('WHERE active = 1');
+        });
+    });
+
+    describe('createCollationConvertTool', () => {
+        it('should convert charset', async () => {
+            mockAdapter.executeReadQuery.mockResolvedValue(createMockQueryResult([]));
+
+            const tool = createCollationConvertTool(mockAdapter as unknown as MySQLAdapter);
+            await tool.handler({
+                table: 'legacy',
+                column: 'text_col',
+                charset: 'utf8mb4'
+            }, mockContext);
+
+            const call = mockAdapter.executeReadQuery.mock.calls[0][0] as string;
+            expect(call).toContain('CONVERT(`text_col` USING utf8mb4)');
+            expect(call).not.toContain('COLLATE');
+        });
+
+        it('should convert charset and collation', async () => {
+            mockAdapter.executeReadQuery.mockResolvedValue(createMockQueryResult([]));
+
+            const tool = createCollationConvertTool(mockAdapter as unknown as MySQLAdapter);
+            await tool.handler({
+                table: 'legacy',
+                column: 'text_col',
+                charset: 'utf8mb4',
+                collation: 'utf8mb4_bin'
+            }, mockContext);
+
+            const call = mockAdapter.executeReadQuery.mock.calls[0][0] as string;
+            expect(call).toContain('CONVERT(`text_col` USING utf8mb4) COLLATE utf8mb4_bin');
+        });
+
+        it('should convert with where clause', async () => {
+            mockAdapter.executeReadQuery.mockResolvedValue(createMockQueryResult([]));
+
+            const tool = createCollationConvertTool(mockAdapter as unknown as MySQLAdapter);
+            await tool.handler({
+                table: 'legacy',
+                column: 'text_col',
+                charset: 'utf8mb4',
+                where: 'id < 1000'
+            }, mockContext);
+
+            const call = mockAdapter.executeReadQuery.mock.calls[0][0] as string;
+            expect(call).toContain('WHERE id < 1000');
+        });
+    });
+});