@berthojoris/mcp-mysql-server 1.0.0

package/dist/tools/ddlTools.js

@@ -0,0 +1,199 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DdlTools = void 0;
+const connection_1 = __importDefault(require("../db/connection"));
+class DdlTools {
+    constructor() {
+        this.db = connection_1.default.getInstance();
+    }
+    /**
+     * Create a new table
+     */
+    async createTable(params) {
+        try {
+            const { table_name, columns, indexes } = params;
+            // Build column definitions
+            const columnDefs = columns.map(col => {
+                let def = `\`${col.name}\` ${col.type}`;
+                if (col.nullable === false) {
+                    def += ' NOT NULL';
+                }
+                if (col.auto_increment) {
+                    def += ' AUTO_INCREMENT';
+                }
+                if (col.default !== undefined) {
+                    def += ` DEFAULT ${col.default}`;
+                }
+                if (col.primary_key) {
+                    def += ' PRIMARY KEY';
+                }
+                return def;
+            }).join(', ');
+            // Build the CREATE TABLE query
+            let query = `CREATE TABLE \`${table_name}\` (${columnDefs})`;
+            // Execute the query
+            await this.db.query(query);
+            // Create indexes if specified
+            if (indexes && indexes.length > 0) {
+                for (const index of indexes) {
+                    const indexType = index.unique ? 'UNIQUE INDEX' : 'INDEX';
+                    const indexColumns = index.columns.map(c => `\`${c}\``).join(', ');
+                    const indexQuery = `CREATE ${indexType} \`${index.name}\` ON \`${table_name}\` (${indexColumns})`;
+                    await this.db.query(indexQuery);
+                }
+            }
+            return {
+                status: 'success',
+                data: {
+                    message: `Table '${table_name}' created successfully`,
+                    table_name
+                }
+            };
+        }
+        catch (error) {
+            return {
+                status: 'error',
+                error: error.message
+            };
+        }
+    }
+    /**
+     * Alter an existing table
+     */
+    async alterTable(params) {
+        try {
+            const { table_name, operations } = params;
+            for (const op of operations) {
+                let query = `ALTER TABLE \`${table_name}\``;
+                switch (op.type) {
+                    case 'add_column':
+                        if (!op.column_name || !op.column_type) {
+                            return { status: 'error', error: 'column_name and column_type required for add_column' };
+                        }
+                        query += ` ADD COLUMN \`${op.column_name}\` ${op.column_type}`;
+                        if (op.nullable === false)
+                            query += ' NOT NULL';
+                        if (op.default !== undefined)
+                            query += ` DEFAULT ${op.default}`;
+                        break;
+                    case 'drop_column':
+                        if (!op.column_name) {
+                            return { status: 'error', error: 'column_name required for drop_column' };
+                        }
+                        query += ` DROP COLUMN \`${op.column_name}\``;
+                        break;
+                    case 'modify_column':
+                        if (!op.column_name || !op.column_type) {
+                            return { status: 'error', error: 'column_name and column_type required for modify_column' };
+                        }
+                        query += ` MODIFY COLUMN \`${op.column_name}\` ${op.column_type}`;
+                        if (op.nullable === false)
+                            query += ' NOT NULL';
+                        if (op.default !== undefined)
+                            query += ` DEFAULT ${op.default}`;
+                        break;
+                    case 'rename_column':
+                        if (!op.column_name || !op.new_column_name || !op.column_type) {
+                            return { status: 'error', error: 'column_name, new_column_name, and column_type required for rename_column' };
+                        }
+                        query += ` CHANGE COLUMN \`${op.column_name}\` \`${op.new_column_name}\` ${op.column_type}`;
+                        break;
+                    case 'add_index':
+                        if (!op.index_name || !op.index_columns) {
+                            return { status: 'error', error: 'index_name and index_columns required for add_index' };
+                        }
+                        const indexType = op.unique ? 'UNIQUE INDEX' : 'INDEX';
+                        const columns = op.index_columns.map(c => `\`${c}\``).join(', ');
+                        query += ` ADD ${indexType} \`${op.index_name}\` (${columns})`;
+                        break;
+                    case 'drop_index':
+                        if (!op.index_name) {
+                            return { status: 'error', error: 'index_name required for drop_index' };
+                        }
+                        query += ` DROP INDEX \`${op.index_name}\``;
+                        break;
+                    default:
+                        return { status: 'error', error: `Unknown operation type: ${op.type}` };
+                }
+                await this.db.query(query);
+            }
+            return {
+                status: 'success',
+                data: {
+                    message: `Table '${table_name}' altered successfully`,
+                    table_name,
+                    operations_count: operations.length
+                }
+            };
+        }
+        catch (error) {
+            return {
+                status: 'error',
+                error: error.message
+            };
+        }
+    }
+    /**
+     * Drop a table
+     */
+    async dropTable(params) {
+        try {
+            const { table_name, if_exists } = params;
+            const ifExistsClause = if_exists ? 'IF EXISTS ' : '';
+            const query = `DROP TABLE ${ifExistsClause}\`${table_name}\``;
+            await this.db.query(query);
+            return {
+                status: 'success',
+                data: {
+                    message: `Table '${table_name}' dropped successfully`,
+                    table_name
+                }
+            };
+        }
+        catch (error) {
+            return {
+                status: 'error',
+                error: error.message
+            };
+        }
+    }
+    /**
+     * Execute raw DDL SQL
+     */
+    async executeDdl(params) {
+        try {
+            const { query } = params;
+            // Basic validation - ensure it's a DDL query
+            const upperQuery = query.trim().toUpperCase();
+            const isDdl = upperQuery.startsWith('CREATE') ||
+                upperQuery.startsWith('ALTER') ||
+                upperQuery.startsWith('DROP') ||
+                upperQuery.startsWith('TRUNCATE') ||
+                upperQuery.startsWith('RENAME');
+            if (!isDdl) {
+                return {
+                    status: 'error',
+                    error: 'Only DDL operations (CREATE, ALTER, DROP, TRUNCATE, RENAME) are allowed with executeDdl'
+                };
+            }
+            const result = await this.db.query(query);
+            return {
+                status: 'success',
+                data: {
+                    message: 'DDL query executed successfully',
+                    affected_rows: result.affectedRows || 0
+                }
+            };
+        }
+        catch (error) {
+            return {
+                status: 'error',
+                error: error.message
+            };
+        }
+    }
+}
+exports.DdlTools = DdlTools;

package/dist/tools/queryTools.d.ts

@@ -0,0 +1,29 @@
+import SecurityLayer from '../security/securityLayer';
+export declare class QueryTools {
+    private db;
+    private security;
+    constructor(security: SecurityLayer);
+    /**
+     * Execute a safe read-only SELECT query
+     */
+    runQuery(queryParams: {
+        query: string;
+        params?: any[];
+    }): Promise<{
+        status: string;
+        data?: any[];
+        error?: string;
+    }>;
+    /**
+     * Execute write operations (INSERT, UPDATE, DELETE) with validation
+     * Note: DDL operations are blocked by the security layer for safety
+     */
+    executeSql(queryParams: {
+        query: string;
+        params?: any[];
+    }): Promise<{
+        status: string;
+        data?: any;
+        error?: string;
+    }>;
+}

package/dist/tools/queryTools.js

@@ -0,0 +1,119 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QueryTools = void 0;
+const connection_1 = __importDefault(require("../db/connection"));
+const schemas_1 = require("../validation/schemas");
+class QueryTools {
+    constructor(security) {
+        this.db = connection_1.default.getInstance();
+        this.security = security;
+    }
+    /**
+     * Execute a safe read-only SELECT query
+     */
+    async runQuery(queryParams) {
+        // Validate input schema
+        if (!(0, schemas_1.validateRunQuery)(queryParams)) {
+            return {
+                status: 'error',
+                error: 'Invalid parameters: ' + JSON.stringify(schemas_1.validateRunQuery.errors)
+            };
+        }
+        try {
+            const { query, params = [] } = queryParams;
+            // Validate query using security layer
+            const queryValidation = this.security.validateQuery(query);
+            if (!queryValidation.valid) {
+                return {
+                    status: 'error',
+                    error: `Query validation failed: ${queryValidation.error}`
+                };
+            }
+            // Ensure it's a SELECT query
+            if (queryValidation.queryType !== 'SELECT') {
+                return {
+                    status: 'error',
+                    error: 'Only SELECT queries are allowed with runQuery. Use executeSql for other operations.'
+                };
+            }
+            // Validate parameters
+            const paramValidation = this.security.validateParameters(params);
+            if (!paramValidation.valid) {
+                return {
+                    status: 'error',
+                    error: `Parameter validation failed: ${paramValidation.error}`
+                };
+            }
+            // Execute the query with sanitized parameters
+            const results = await this.db.query(query, paramValidation.sanitizedParams);
+            return {
+                status: 'success',
+                data: results
+            };
+        }
+        catch (error) {
+            return {
+                status: 'error',
+                error: error.message
+            };
+        }
+    }
+    /**
+     * Execute write operations (INSERT, UPDATE, DELETE) with validation
+     * Note: DDL operations are blocked by the security layer for safety
+     */
+    async executeSql(queryParams) {
+        // Validate input schema
+        if (!(0, schemas_1.validateRunQuery)(queryParams)) {
+            return {
+                status: 'error',
+                error: 'Invalid parameters: ' + JSON.stringify(schemas_1.validateRunQuery.errors)
+            };
+        }
+        try {
+            const { query, params = [] } = queryParams;
+            // Validate query using security layer
+            const queryValidation = this.security.validateQuery(query);
+            if (!queryValidation.valid) {
+                return {
+                    status: 'error',
+                    error: `Query validation failed: ${queryValidation.error}`
+                };
+            }
+            // Ensure it's not a SELECT query (use runQuery for that)
+            if (queryValidation.queryType === 'SELECT') {
+                return {
+                    status: 'error',
+                    error: 'SELECT queries should use runQuery method instead of executeSql.'
+                };
+            }
+            // Validate parameters
+            const paramValidation = this.security.validateParameters(params);
+            if (!paramValidation.valid) {
+                return {
+                    status: 'error',
+                    error: `Parameter validation failed: ${paramValidation.error}`
+                };
+            }
+            // Execute the query with sanitized parameters
+            const result = await this.db.query(query, paramValidation.sanitizedParams);
+            return {
+                status: 'success',
+                data: {
+                    affectedRows: result.affectedRows || 0,
+                    insertId: result.insertId || null
+                }
+            };
+        }
+        catch (error) {
+            return {
+                status: 'error',
+                error: error.message
+            };
+        }
+    }
+}
+exports.QueryTools = QueryTools;

package/dist/tools/storedProcedureTools.d.ts

@@ -0,0 +1,80 @@
+import { SecurityLayer } from '../security/securityLayer';
+export declare class StoredProcedureTools {
+    private db;
+    private security;
+    constructor(security: SecurityLayer);
+    /**
+     * List all stored procedures in the current database
+     */
+    listStoredProcedures(params: {
+        database?: string;
+    }): Promise<{
+        status: string;
+        data?: any[];
+        error?: string;
+    }>;
+    /**
+     * Get detailed information about a specific stored procedure
+     */
+    getStoredProcedureInfo(params: {
+        procedure_name: string;
+        database?: string;
+    }): Promise<{
+        status: string;
+        data?: any;
+        error?: string;
+    }>;
+    /**
+     * Execute a stored procedure with parameters
+     */
+    executeStoredProcedure(params: {
+        procedure_name: string;
+        parameters?: any[];
+        database?: string;
+    }): Promise<{
+        status: string;
+        data?: any;
+        error?: string;
+    }>;
+    /**
+     * Create a new stored procedure
+     */
+    createStoredProcedure(params: {
+        procedure_name: string;
+        parameters?: Array<{
+            name: string;
+            mode: 'IN' | 'OUT' | 'INOUT';
+            data_type: string;
+        }>;
+        body: string;
+        comment?: string;
+        database?: string;
+    }): Promise<{
+        status: string;
+        data?: any;
+        error?: string;
+    }>;
+    /**
+     * Drop a stored procedure
+     */
+    dropStoredProcedure(params: {
+        procedure_name: string;
+        if_exists?: boolean;
+        database?: string;
+    }): Promise<{
+        status: string;
+        message?: string;
+        error?: string;
+    }>;
+    /**
+     * Show the CREATE statement for a stored procedure
+     */
+    showCreateProcedure(params: {
+        procedure_name: string;
+        database?: string;
+    }): Promise<{
+        status: string;
+        data?: any;
+        error?: string;
+    }>;
+}