@neverinfamous/mysql-mcp 2.1.0

package/src/adapters/mysql/tools/schema/__tests__/management.test.ts

@@ -0,0 +1,122 @@
+
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { createListSchemasTool, createCreateSchemaTool, createDropSchemaTool } from '../management.js';
+import type { MySQLAdapter } from '../../../MySQLAdapter.js';
+import { createMockMySQLAdapter, createMockRequestContext, createMockQueryResult } from '../../../../../__tests__/mocks/index.js';
+
+describe('Schema Management Tools', () => {
+    let mockAdapter: ReturnType<typeof createMockMySQLAdapter>;
+    let mockContext: ReturnType<typeof createMockRequestContext>;
+
+    beforeEach(() => {
+        vi.clearAllMocks();
+        mockAdapter = createMockMySQLAdapter();
+        mockContext = createMockRequestContext();
+    });
+
+    describe('mysql_list_schemas', () => {
+        it('should list and filter schemas', async () => {
+            const tool = createListSchemasTool(mockAdapter as unknown as MySQLAdapter);
+
+            mockAdapter.executeQuery.mockResolvedValue(createMockQueryResult([
+                { name: 'db1', charset: 'utf8', collation: 'utf8_bin' },
+                { name: 'db2', charset: 'utf8mb4', collation: 'utf8mb4_unicode_ci' }
+            ]));
+
+            const result = await tool.handler({ pattern: 'db%' }, mockContext);
+
+            expect(mockAdapter.executeQuery).toHaveBeenCalledWith(
+                expect.stringContaining('LIKE ?'),
+                ['db%']
+            );
+            expect(result).toHaveProperty('schemas');
+            expect(result).toHaveProperty('count', 2);
+        });
+
+        it('should list all schemas if no pattern provided', async () => {
+            const tool = createListSchemasTool(mockAdapter as unknown as MySQLAdapter);
+            mockAdapter.executeQuery.mockResolvedValue(createMockQueryResult([]));
+
+            await tool.handler({}, mockContext);
+
+            expect(mockAdapter.executeQuery).toHaveBeenCalledWith(
+                expect.not.stringContaining('LIKE ?'),
+                []
+            );
+        });
+    });
+
+    describe('mysql_create_schema', () => {
+        it('should create schema with default settings', async () => {
+            const tool = createCreateSchemaTool(mockAdapter as unknown as MySQLAdapter);
+            mockAdapter.executeQuery.mockResolvedValue(createMockQueryResult([]));
+
+            const result = await tool.handler({ name: 'new_db' }, mockContext);
+
+            expect(mockAdapter.executeQuery).toHaveBeenCalled();
+            const sql = mockAdapter.executeQuery.mock.calls[0][0] as string;
+            expect(sql).toContain('CREATE DATABASE IF NOT EXISTS `new_db`');
+            expect(sql).toContain('utf8mb4'); // defaults
+            expect(result).toHaveProperty('success', true);
+        });
+
+        it('should reject invalid schema names', async () => {
+            const tool = createCreateSchemaTool(mockAdapter as unknown as MySQLAdapter);
+            await expect(tool.handler({ name: 'invalid-name' }, mockContext)).rejects.toThrow('Invalid schema name');
+        });
+
+        it('should use custom charset and collation', async () => {
+            const tool = createCreateSchemaTool(mockAdapter as unknown as MySQLAdapter);
+            mockAdapter.executeQuery.mockResolvedValue(createMockQueryResult([]));
+
+            await tool.handler({
+                name: 'custom_db',
+                charset: 'latin1',
+                collation: 'latin1_swedish_ci',
+                ifNotExists: false
+            }, mockContext);
+
+            const sql = mockAdapter.executeQuery.mock.calls[0][0] as string;
+            expect(sql).toContain('CREATE DATABASE `custom_db`'); // no IF NOT EXISTS
+            expect(sql).toContain('latin1');
+            expect(sql).toContain('latin1_swedish_ci');
+        });
+    });
+
+    describe('mysql_drop_schema', () => {
+        it('should drop schema with IF EXISTS by default', async () => {
+            const tool = createDropSchemaTool(mockAdapter as unknown as MySQLAdapter);
+            mockAdapter.executeQuery.mockResolvedValue(createMockQueryResult([]));
+
+            const result = await tool.handler({ name: 'old_db' }, mockContext);
+
+            const sql = mockAdapter.executeQuery.mock.calls[0][0] as string;
+            expect(sql).toContain('DROP DATABASE IF EXISTS `old_db`');
+            expect(result).toHaveProperty('success', true);
+        });
+
+        it('should fail if attempting to drop system schema', async () => {
+            const tool = createDropSchemaTool(mockAdapter as unknown as MySQLAdapter);
+
+            await expect(tool.handler({ name: 'mysql' }, mockContext)).rejects.toThrow('Cannot drop system schema');
+            await expect(tool.handler({ name: 'information_schema' }, mockContext)).rejects.toThrow('Cannot drop system schema');
+            await expect(tool.handler({ name: 'performance_schema' }, mockContext)).rejects.toThrow('Cannot drop system schema');
+            await expect(tool.handler({ name: 'sys' }, mockContext)).rejects.toThrow('Cannot drop system schema');
+        });
+
+        it('should reject invalid schema names', async () => {
+            const tool = createDropSchemaTool(mockAdapter as unknown as MySQLAdapter);
+            await expect(tool.handler({ name: 'invalid-db' }, mockContext)).rejects.toThrow('Invalid schema name');
+        });
+
+        it('should drop schema without IF EXISTS if requested', async () => {
+            const tool = createDropSchemaTool(mockAdapter as unknown as MySQLAdapter);
+            mockAdapter.executeQuery.mockResolvedValue(createMockQueryResult([]));
+
+            await tool.handler({ name: 'db', ifExists: false }, mockContext);
+
+            const sql = mockAdapter.executeQuery.mock.calls[0][0] as string;
+            expect(sql).toBe('DROP DATABASE `db`');
+        });
+    });
+});

package/src/adapters/mysql/tools/schema/__tests__/routines.test.ts

@@ -0,0 +1,45 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { createListStoredProceduresTool, createListFunctionsTool } from '../routines.js';
+import type { MySQLAdapter } from '../../../MySQLAdapter.js';
+import { createMockMySQLAdapter, createMockRequestContext, createMockQueryResult } from '../../../../../__tests__/mocks/index.js';
+
+describe('Schema Routine Tools', () => {
+    let mockAdapter: ReturnType<typeof createMockMySQLAdapter>;
+    let mockContext: ReturnType<typeof createMockRequestContext>;
+
+    beforeEach(() => {
+        vi.clearAllMocks();
+        mockAdapter = createMockMySQLAdapter();
+        mockContext = createMockRequestContext();
+    });
+
+    describe('mysql_list_stored_procedures', () => {
+        it('should query INFORMATION_SCHEMA for routines', async () => {
+            mockAdapter.executeQuery.mockResolvedValue(createMockQueryResult([
+                { ROUTINE_NAME: 'get_users', ROUTINE_TYPE: 'PROCEDURE' }
+            ]));
+
+            const tool = createListStoredProceduresTool(mockAdapter as unknown as MySQLAdapter);
+            const result = await tool.handler({}, mockContext);
+
+            expect(mockAdapter.executeQuery).toHaveBeenCalled();
+            const call = mockAdapter.executeQuery.mock.calls[0][0] as string;
+            expect(call).toContain('information_schema.ROUTINES');
+            expect(result).toBeDefined();
+        });
+    });
+
+    describe('mysql_list_functions', () => {
+        it('should query INFORMATION_SCHEMA for functions', async () => {
+            mockAdapter.executeQuery.mockResolvedValue(createMockQueryResult([
+                { ROUTINE_NAME: 'calc_total', ROUTINE_TYPE: 'FUNCTION' }
+            ]));
+
+            const tool = createListFunctionsTool(mockAdapter as unknown as MySQLAdapter);
+            const result = await tool.handler({}, mockContext);
+
+            expect(mockAdapter.executeQuery).toHaveBeenCalled();
+            expect(result).toBeDefined();
+        });
+    });
+});

package/src/adapters/mysql/tools/schema/__tests__/scheduled_events.test.ts

@@ -0,0 +1,44 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { createListEventsTool } from '../scheduled_events.js';
+import type { MySQLAdapter } from '../../../MySQLAdapter.js';
+import { createMockMySQLAdapter, createMockRequestContext, createMockQueryResult } from '../../../../../__tests__/mocks/index.js';
+
+describe('Schema Event Tools', () => {
+    let mockAdapter: ReturnType<typeof createMockMySQLAdapter>;
+    let mockContext: ReturnType<typeof createMockRequestContext>;
+
+    beforeEach(() => {
+        vi.clearAllMocks();
+        mockAdapter = createMockMySQLAdapter();
+        mockContext = createMockRequestContext();
+    });
+
+    describe('mysql_list_events', () => {
+        it('should query INFORMATION_SCHEMA for events', async () => {
+            mockAdapter.executeQuery.mockResolvedValue(createMockQueryResult([
+                { EVENT_NAME: 'daily_cleanup', STATUS: 'ENABLED' }
+            ]));
+
+            const tool = createListEventsTool(mockAdapter as unknown as MySQLAdapter);
+            const result = await tool.handler({}, mockContext);
+
+            expect(mockAdapter.executeQuery).toHaveBeenCalled();
+            const call = mockAdapter.executeQuery.mock.calls[0][0] as string;
+            expect(call).toContain('information_schema.EVENTS');
+            expect(result).toBeDefined();
+        });
+
+        it('should filter by status when provided', async () => {
+            mockAdapter.executeQuery.mockResolvedValue(createMockQueryResult([]));
+
+            const tool = createListEventsTool(mockAdapter as unknown as MySQLAdapter);
+            await tool.handler({ status: 'ENABLED' }, mockContext);
+
+            expect(mockAdapter.executeQuery).toHaveBeenCalled();
+            const call = mockAdapter.executeQuery.mock.calls[0][0] as string;
+            expect(call).toContain('STATUS = ?');
+            const params = mockAdapter.executeQuery.mock.calls[0][1] as unknown[];
+            expect(params).toContain('ENABLED');
+        });
+    });
+});

package/src/adapters/mysql/tools/schema/__tests__/triggers.test.ts

@@ -0,0 +1,44 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { createListTriggersTool } from '../triggers.js';
+import type { MySQLAdapter } from '../../../MySQLAdapter.js';
+import { createMockMySQLAdapter, createMockRequestContext, createMockQueryResult } from '../../../../../__tests__/mocks/index.js';
+
+describe('Schema Trigger Tools', () => {
+    let mockAdapter: ReturnType<typeof createMockMySQLAdapter>;
+    let mockContext: ReturnType<typeof createMockRequestContext>;
+
+    beforeEach(() => {
+        vi.clearAllMocks();
+        mockAdapter = createMockMySQLAdapter();
+        mockContext = createMockRequestContext();
+    });
+
+    describe('mysql_list_triggers', () => {
+        it('should query INFORMATION_SCHEMA for triggers', async () => {
+            mockAdapter.executeQuery.mockResolvedValue(createMockQueryResult([
+                { TRIGGER_NAME: 'before_insert', EVENT_MANIPULATION: 'INSERT' }
+            ]));
+
+            const tool = createListTriggersTool(mockAdapter as unknown as MySQLAdapter);
+            const result = await tool.handler({}, mockContext);
+
+            expect(mockAdapter.executeQuery).toHaveBeenCalled();
+            const call = mockAdapter.executeQuery.mock.calls[0][0] as string;
+            expect(call).toContain('information_schema.TRIGGERS');
+            expect(result).toBeDefined();
+        });
+
+        it('should filter by table when provided', async () => {
+            mockAdapter.executeQuery.mockResolvedValue(createMockQueryResult([]));
+
+            const tool = createListTriggersTool(mockAdapter as unknown as MySQLAdapter);
+            await tool.handler({ table: 'users' }, mockContext);
+
+            expect(mockAdapter.executeQuery).toHaveBeenCalled();
+            const call = mockAdapter.executeQuery.mock.calls[0][0] as string;
+            expect(call).toContain('EVENT_OBJECT_TABLE = ?');
+            const params = mockAdapter.executeQuery.mock.calls[0][1] as unknown[];
+            expect(params).toContain('users');
+        });
+    });
+});

package/src/adapters/mysql/tools/schema/__tests__/views.test.ts

@@ -0,0 +1,85 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { createListViewsTool, createCreateViewTool } from '../views.js';
+import type { MySQLAdapter } from '../../../MySQLAdapter.js';
+import { createMockMySQLAdapter, createMockRequestContext, createMockQueryResult } from '../../../../../__tests__/mocks/index.js';
+
+describe('Schema View Tools', () => {
+    let mockAdapter: ReturnType<typeof createMockMySQLAdapter>;
+    let mockContext: ReturnType<typeof createMockRequestContext>;
+
+    beforeEach(() => {
+        vi.clearAllMocks();
+        mockAdapter = createMockMySQLAdapter();
+        mockContext = createMockRequestContext();
+    });
+
+    describe('mysql_list_views', () => {
+        it('should query INFORMATION_SCHEMA for views', async () => {
+            mockAdapter.executeQuery.mockResolvedValue(
+                createMockQueryResult([{ TABLE_NAME: 'user_view', VIEW_DEFINITION: 'SELECT * FROM users' }])
+            );
+
+            const tool = createListViewsTool(mockAdapter as unknown as MySQLAdapter);
+            const result = await tool.handler({}, mockContext);
+
+            expect(mockAdapter.executeQuery).toHaveBeenCalled();
+            const call = mockAdapter.executeQuery.mock.calls[0][0] as string;
+            expect(call).toContain('information_schema.VIEWS');
+            expect(result).toBeDefined();
+        });
+    });
+
+    describe('mysql_create_view', () => {
+        it('should execute CREATE VIEW query', async () => {
+            mockAdapter.executeQuery.mockResolvedValue(createMockQueryResult([]));
+
+            const tool = createCreateViewTool(mockAdapter as unknown as MySQLAdapter);
+            const result = await tool.handler({
+                name: 'active_users',
+                definition: 'SELECT * FROM users WHERE active = 1'
+            }, mockContext) as { success: boolean };
+
+            expect(mockAdapter.executeQuery).toHaveBeenCalled();
+            const call = mockAdapter.executeQuery.mock.calls[0][0] as string;
+            expect(call).toContain('CREATE');
+            expect(call).toContain('VIEW');
+            expect(result.success).toBe(true);
+        });
+
+        it('should use CREATE OR REPLACE when orReplace is true', async () => {
+            mockAdapter.executeQuery.mockResolvedValue(createMockQueryResult([]));
+
+            const tool = createCreateViewTool(mockAdapter as unknown as MySQLAdapter);
+            await tool.handler({
+                name: 'active_users',
+                definition: 'SELECT * FROM users WHERE active = 1',
+                orReplace: true
+            }, mockContext);
+
+            const call = mockAdapter.executeQuery.mock.calls[0][0] as string;
+            expect(call).toContain('OR REPLACE');
+        });
+
+        it('should validate view name', async () => {
+            const tool = createCreateViewTool(mockAdapter as unknown as MySQLAdapter);
+            await expect(tool.handler({
+                name: 'invalid-name',
+                definition: 'SELECT 1'
+            }, mockContext)).rejects.toThrow('Invalid view name');
+        });
+
+        it('should include WITH CHECK OPTION when specified', async () => {
+            mockAdapter.executeQuery.mockResolvedValue(createMockQueryResult([]));
+            const tool = createCreateViewTool(mockAdapter as unknown as MySQLAdapter);
+
+            await tool.handler({
+                name: 'valid_view',
+                definition: 'SELECT * FROM t1',
+                checkOption: 'CASCADED'
+            }, mockContext);
+
+            const call = mockAdapter.executeQuery.mock.calls[0][0] as string;
+            expect(call).toContain('WITH CASCADED CHECK OPTION');
+        });
+    });
+});

package/src/adapters/mysql/tools/schema/constraints.ts

@@ -0,0 +1,77 @@
+import { z } from 'zod';
+import type { MySQLAdapter } from '../../MySQLAdapter.js';
+import type { ToolDefinition, RequestContext } from '../../../../types/index.js';
+
+const ListConstraintsSchema = z.object({
+    table: z.string().describe('Table name'),
+    type: z.enum(['PRIMARY KEY', 'FOREIGN KEY', 'UNIQUE', 'CHECK']).optional().describe('Filter by constraint type')
+});
+
+/**
+ * List constraints
+ */
+export function createListConstraintsTool(adapter: MySQLAdapter): ToolDefinition {
+    return {
+        name: 'mysql_list_constraints',
+        title: 'MySQL List Constraints',
+        description: 'List all constraints (primary key, foreign key, unique, check) for a table.',
+        group: 'schema',
+        inputSchema: ListConstraintsSchema,
+        requiredScopes: ['read'],
+        annotations: {
+            readOnlyHint: true,
+            idempotentHint: true
+        },
+        handler: async (params: unknown, _context: RequestContext) => {
+            const { table, type } = ListConstraintsSchema.parse(params);
+
+            const parts = table.split('.');
+            let schemaName: string | null = null;
+            let tableName = table;
+
+            if (parts.length === 2 && parts[0] && parts[1]) {
+                schemaName = parts[0];
+                tableName = parts[1];
+            }
+
+            // Query for table constraints
+            let query = `
+                SELECT 
+                    tc.CONSTRAINT_NAME as name,
+                    tc.CONSTRAINT_TYPE as type,
+                    tc.TABLE_NAME as tableName,
+                    GROUP_CONCAT(kcu.COLUMN_NAME ORDER BY kcu.ORDINAL_POSITION) as columns,
+                    kcu.REFERENCED_TABLE_NAME as referencedTable,
+                    GROUP_CONCAT(kcu.REFERENCED_COLUMN_NAME ORDER BY kcu.ORDINAL_POSITION) as referencedColumns,
+                    rc.UPDATE_RULE as onUpdate,
+                    rc.DELETE_RULE as onDelete
+                FROM information_schema.TABLE_CONSTRAINTS tc
+                LEFT JOIN information_schema.KEY_COLUMN_USAGE kcu 
+                    ON tc.CONSTRAINT_NAME = kcu.CONSTRAINT_NAME 
+                    AND tc.TABLE_SCHEMA = kcu.TABLE_SCHEMA
+                    AND tc.TABLE_NAME = kcu.TABLE_NAME
+                LEFT JOIN information_schema.REFERENTIAL_CONSTRAINTS rc
+                    ON tc.CONSTRAINT_NAME = rc.CONSTRAINT_NAME
+                    AND tc.TABLE_SCHEMA = rc.CONSTRAINT_SCHEMA
+                WHERE tc.TABLE_SCHEMA = COALESCE(?, DATABASE())
+                  AND tc.TABLE_NAME = ?
+            `;
+
+            const queryParams: unknown[] = [schemaName, tableName];
+
+            if (type) {
+                query += ' AND tc.CONSTRAINT_TYPE = ?';
+                queryParams.push(type);
+            }
+
+            query += ' GROUP BY tc.CONSTRAINT_NAME, tc.CONSTRAINT_TYPE, tc.TABLE_NAME, kcu.REFERENCED_TABLE_NAME, rc.UPDATE_RULE, rc.DELETE_RULE';
+            query += ' ORDER BY tc.CONSTRAINT_TYPE, tc.CONSTRAINT_NAME';
+
+            const result = await adapter.executeQuery(query, queryParams);
+            return {
+                constraints: result.rows,
+                count: result.rows?.length ?? 0
+            };
+        }
+    };
+}

package/src/adapters/mysql/tools/schema/index.ts

@@ -0,0 +1,54 @@
+/**
+ * MySQL Schema Management Tools
+ * 
+ * Tools for database schema introspection and management.
+ */
+
+import type { MySQLAdapter } from '../../MySQLAdapter.js';
+import type { ToolDefinition } from '../../../../types/index.js';
+
+import {
+    createListSchemasTool,
+    createCreateSchemaTool,
+    createDropSchemaTool
+} from './management.js';
+
+import {
+    createListViewsTool,
+    createCreateViewTool
+} from './views.js';
+
+import {
+    createListStoredProceduresTool,
+    createListFunctionsTool
+} from './routines.js';
+
+import {
+    createListTriggersTool
+} from './triggers.js';
+
+import {
+    createListConstraintsTool
+} from './constraints.js';
+
+import {
+    createListEventsTool
+} from './scheduled_events.js';
+
+/**
+ * Get all schema management tools
+ */
+export function getSchemaTools(adapter: MySQLAdapter): ToolDefinition[] {
+    return [
+        createListSchemasTool(adapter),
+        createCreateSchemaTool(adapter),
+        createDropSchemaTool(adapter),
+        createListViewsTool(adapter),
+        createCreateViewTool(adapter),
+        createListStoredProceduresTool(adapter),
+        createListFunctionsTool(adapter),
+        createListTriggersTool(adapter),
+        createListConstraintsTool(adapter),
+        createListEventsTool(adapter)
+    ];
+}

package/src/adapters/mysql/tools/schema/management.ts

@@ -0,0 +1,131 @@
+import { z } from 'zod';
+import type { MySQLAdapter } from '../../MySQLAdapter.js';
+import type { ToolDefinition, RequestContext } from '../../../../types/index.js';
+
+const ListSchemasSchema = z.object({
+    pattern: z.string().optional().describe('Filter pattern (LIKE syntax, e.g. "app_%")')
+});
+
+const CreateSchemaSchema = z.object({
+    name: z.string().describe('Schema/database name'),
+    charset: z.string().default('utf8mb4').describe('Character set'),
+    collation: z.string().default('utf8mb4_unicode_ci').describe('Collation'),
+    ifNotExists: z.boolean().default(true).describe('Add IF NOT EXISTS clause')
+});
+
+const DropSchemaSchema = z.object({
+    name: z.string().describe('Schema/database name to drop'),
+    ifExists: z.boolean().default(true).describe('Add IF EXISTS clause')
+});
+
+/**
+ * List all schemas/databases
+ */
+export function createListSchemasTool(adapter: MySQLAdapter): ToolDefinition {
+    return {
+        name: 'mysql_list_schemas',
+        title: 'MySQL List Schemas',
+        description: 'List all databases/schemas with metadata including charset and collation.',
+        group: 'schema',
+        inputSchema: ListSchemasSchema,
+        requiredScopes: ['read'],
+        annotations: {
+            readOnlyHint: true,
+            idempotentHint: true
+        },
+        handler: async (params: unknown, _context: RequestContext) => {
+            const { pattern } = ListSchemasSchema.parse(params);
+
+            let query = `
+                SELECT 
+                    SCHEMA_NAME as name,
+                    DEFAULT_CHARACTER_SET_NAME as charset,
+                    DEFAULT_COLLATION_NAME as collation
+                FROM information_schema.SCHEMATA
+                WHERE SCHEMA_NAME NOT IN ('information_schema', 'mysql', 'performance_schema', 'sys')
+            `;
+
+            const queryParams: unknown[] = [];
+            if (pattern) {
+                query += ' AND SCHEMA_NAME LIKE ?';
+                queryParams.push(pattern);
+            }
+
+            query += ' ORDER BY SCHEMA_NAME';
+
+            const result = await adapter.executeQuery(query, queryParams);
+            return {
+                schemas: result.rows,
+                count: result.rows?.length ?? 0
+            };
+        }
+    };
+}
+
+/**
+ * Create a new schema/database
+ */
+export function createCreateSchemaTool(adapter: MySQLAdapter): ToolDefinition {
+    return {
+        name: 'mysql_create_schema',
+        title: 'MySQL Create Schema',
+        description: 'Create a new database/schema with specified charset and collation.',
+        group: 'schema',
+        inputSchema: CreateSchemaSchema,
+        requiredScopes: ['admin'],
+        annotations: {
+            readOnlyHint: false
+        },
+        handler: async (params: unknown, _context: RequestContext) => {
+            const { name, charset, collation, ifNotExists } = CreateSchemaSchema.parse(params);
+
+            // Validate schema name
+            if (!/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(name)) {
+                throw new Error('Invalid schema name');
+            }
+
+            const ifNotExistsClause = ifNotExists ? 'IF NOT EXISTS ' : '';
+            const sql = `CREATE DATABASE ${ifNotExistsClause}\`${name}\` CHARACTER SET ${charset} COLLATE ${collation}`;
+
+            await adapter.executeQuery(sql);
+            return { success: true, schemaName: name };
+        }
+    };
+}
+
+/**
+ * Drop a schema/database
+ */
+export function createDropSchemaTool(adapter: MySQLAdapter): ToolDefinition {
+    return {
+        name: 'mysql_drop_schema',
+        title: 'MySQL Drop Schema',
+        description: 'Drop a database/schema. WARNING: This permanently deletes all data.',
+        group: 'schema',
+        inputSchema: DropSchemaSchema,
+        requiredScopes: ['admin'],
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: true
+        },
+        handler: async (params: unknown, _context: RequestContext) => {
+            const { name, ifExists } = DropSchemaSchema.parse(params);
+
+            // Validate schema name
+            if (!/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(name)) {
+                throw new Error('Invalid schema name');
+            }
+
+            // Protect system schemas
+            const systemSchemas = ['mysql', 'information_schema', 'performance_schema', 'sys'];
+            if (systemSchemas.includes(name.toLowerCase())) {
+                throw new Error('Cannot drop system schema');
+            }
+
+            const ifExistsClause = ifExists ? 'IF EXISTS ' : '';
+            await adapter.executeQuery(`DROP DATABASE ${ifExistsClause}\`${name}\``);
+
+            return { success: true, schemaName: name };
+        }
+    };
+}