@berthojoris/mcp-mysql-server 1.6.2 → 1.7.0

package/dist/tools/backupRestoreTools.js

@@ -0,0 +1,584 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BackupRestoreTools = void 0;
+const connection_1 = __importDefault(require("../db/connection"));
+const config_1 = require("../config/config");
+/**
+ * Backup and Restore Tools for MySQL MCP Server
+ * Provides database backup (SQL dump generation) and restore functionality
+ */
+class BackupRestoreTools {
+    constructor(security) {
+        this.db = connection_1.default.getInstance();
+        this.security = security;
+    }
+    /**
+     * Validate database access
+     */
+    validateDatabaseAccess(requestedDatabase) {
+        const connectedDatabase = config_1.dbConfig.database;
+        if (!connectedDatabase) {
+            return {
+                valid: false,
+                database: '',
+                error: 'No database configured. Please specify a database in your connection settings.'
+            };
+        }
+        if (requestedDatabase && requestedDatabase !== connectedDatabase) {
+            return {
+                valid: false,
+                database: '',
+                error: `Access denied: You are connected to '${connectedDatabase}' but requested '${requestedDatabase}'. Cross-database access is not permitted.`
+            };
+        }
+        return {
+            valid: true,
+            database: connectedDatabase
+        };
+    }
+    /**
+     * Escape string value for SQL
+     */
+    escapeValue(value) {
+        if (value === null)
+            return 'NULL';
+        if (typeof value === 'number')
+            return String(value);
+        if (typeof value === 'boolean')
+            return value ? '1' : '0';
+        if (value instanceof Date) {
+            return `'${value.toISOString().slice(0, 19).replace('T', ' ')}'`;
+        }
+        if (Buffer.isBuffer(value)) {
+            return `X'${value.toString('hex')}'`;
+        }
+        // Escape string
+        const escaped = String(value)
+            .replace(/\\/g, '\\\\')
+            .replace(/'/g, "\\'")
+            .replace(/"/g, '\\"')
+            .replace(/\n/g, '\\n')
+            .replace(/\r/g, '\\r')
+            .replace(/\t/g, '\\t')
+            .replace(/\0/g, '\\0');
+        return `'${escaped}'`;
+    }
+    /**
+     * Get CREATE TABLE statement for a table
+     */
+    async getCreateTableStatement(params) {
+        try {
+            const { table_name, database } = params;
+            // Validate database access
+            const dbValidation = this.validateDatabaseAccess(database);
+            if (!dbValidation.valid) {
+                return { status: 'error', error: dbValidation.error };
+            }
+            // Validate table name
+            const tableValidation = this.security.validateIdentifier(table_name);
+            if (!tableValidation.valid) {
+                return { status: 'error', error: tableValidation.error };
+            }
+            const escapedTable = this.security.escapeIdentifier(table_name);
+            const query = `SHOW CREATE TABLE ${escapedTable}`;
+            const results = await this.db.query(query);
+            if (results.length === 0) {
+                return {
+                    status: 'error',
+                    error: `Table '${table_name}' not found`,
+                    queryLog: this.db.getFormattedQueryLogs(1)
+                };
+            }
+            return {
+                status: 'success',
+                data: {
+                    table_name: table_name,
+                    create_statement: results[0]['Create Table']
+                },
+                queryLog: this.db.getFormattedQueryLogs(1)
+            };
+        }
+        catch (error) {
+            return {
+                status: 'error',
+                error: error.message,
+                queryLog: this.db.getFormattedQueryLogs(1)
+            };
+        }
+    }
+    /**
+     * Backup a single table to SQL dump format
+     */
+    async backupTable(params) {
+        try {
+            const { table_name, include_data = true, include_drop = true, database } = params;
+            // Validate database access
+            const dbValidation = this.validateDatabaseAccess(database);
+            if (!dbValidation.valid) {
+                return { status: 'error', error: dbValidation.error };
+            }
+            // Validate table name
+            const tableValidation = this.security.validateIdentifier(table_name);
+            if (!tableValidation.valid) {
+                return { status: 'error', error: tableValidation.error };
+            }
+            const escapedTable = this.security.escapeIdentifier(table_name);
+            let sqlDump = '';
+            let queryCount = 0;
+            // Add header comment
+            sqlDump += `-- MySQL Dump generated by MySQL MCP Server\n`;
+            sqlDump += `-- Table: ${table_name}\n`;
+            sqlDump += `-- Generated at: ${new Date().toISOString()}\n`;
+            sqlDump += `-- --------------------------------------------------------\n\n`;
+            // Add DROP TABLE IF EXISTS
+            if (include_drop) {
+                sqlDump += `DROP TABLE IF EXISTS ${escapedTable};\n\n`;
+            }
+            // Get CREATE TABLE statement
+            const createQuery = `SHOW CREATE TABLE ${escapedTable}`;
+            const createResults = await this.db.query(createQuery);
+            queryCount++;
+            if (createResults.length === 0) {
+                return {
+                    status: 'error',
+                    error: `Table '${table_name}' not found`,
+                    queryLog: this.db.getFormattedQueryLogs(queryCount)
+                };
+            }
+            sqlDump += `${createResults[0]['Create Table']};\n\n`;
+            // Get table data if requested
+            let rowCount = 0;
+            if (include_data) {
+                const dataQuery = `SELECT * FROM ${escapedTable}`;
+                const dataResults = await this.db.query(dataQuery);
+                queryCount++;
+                if (dataResults.length > 0) {
+                    rowCount = dataResults.length;
+                    const columns = Object.keys(dataResults[0]);
+                    const escapedColumns = columns.map(c => this.security.escapeIdentifier(c)).join(', ');
+                    sqlDump += `-- Data for table ${table_name}\n`;
+                    sqlDump += `LOCK TABLES ${escapedTable} WRITE;\n`;
+                    sqlDump += `/*!40000 ALTER TABLE ${escapedTable} DISABLE KEYS */;\n\n`;
+                    // Generate INSERT statements in batches
+                    const batchSize = 100;
+                    for (let i = 0; i < dataResults.length; i += batchSize) {
+                        const batch = dataResults.slice(i, i + batchSize);
+                        const values = batch.map(row => {
+                            const rowValues = columns.map(col => this.escapeValue(row[col]));
+                            return `(${rowValues.join(', ')})`;
+                        }).join(',\n');
+                        sqlDump += `INSERT INTO ${escapedTable} (${escapedColumns}) VALUES\n${values};\n\n`;
+                    }
+                    sqlDump += `/*!40000 ALTER TABLE ${escapedTable} ENABLE KEYS */;\n`;
+                    sqlDump += `UNLOCK TABLES;\n`;
+                }
+            }
+            return {
+                status: 'success',
+                data: {
+                    table_name: table_name,
+                    sql_dump: sqlDump,
+                    row_count: rowCount,
+                    include_data: include_data,
+                    include_drop: include_drop
+                },
+                queryLog: this.db.getFormattedQueryLogs(queryCount)
+            };
+        }
+        catch (error) {
+            return {
+                status: 'error',
+                error: error.message,
+                queryLog: this.db.getFormattedQueryLogs(1)
+            };
+        }
+    }
+    /**
+     * Backup entire database schema and optionally data
+     */
+    async backupDatabase(params) {
+        try {
+            const { include_data = true, include_drop = true, tables, database } = params;
+            // Validate database access
+            const dbValidation = this.validateDatabaseAccess(database);
+            if (!dbValidation.valid) {
+                return { status: 'error', error: dbValidation.error };
+            }
+            let sqlDump = '';
+            let queryCount = 0;
+            let totalRows = 0;
+            const backedUpTables = [];
+            // Add header
+            sqlDump += `-- MySQL Database Dump generated by MySQL MCP Server\n`;
+            sqlDump += `-- Database: ${dbValidation.database}\n`;
+            sqlDump += `-- Generated at: ${new Date().toISOString()}\n`;
+            sqlDump += `-- --------------------------------------------------------\n\n`;
+            sqlDump += `SET FOREIGN_KEY_CHECKS=0;\n`;
+            sqlDump += `SET SQL_MODE='NO_AUTO_VALUE_ON_ZERO';\n`;
+            sqlDump += `SET AUTOCOMMIT=0;\n`;
+            sqlDump += `START TRANSACTION;\n\n`;
+            // Get list of tables
+            let tableList;
+            if (tables && tables.length > 0) {
+                // Validate each table name
+                for (const tableName of tables) {
+                    const validation = this.security.validateIdentifier(tableName);
+                    if (!validation.valid) {
+                        return { status: 'error', error: `Invalid table name: ${tableName}` };
+                    }
+                }
+                tableList = tables;
+            }
+            else {
+                const tablesQuery = `SHOW TABLES`;
+                const tablesResult = await this.db.query(tablesQuery);
+                queryCount++;
+                tableList = tablesResult.map(row => Object.values(row)[0]);
+            }
+            // Backup each table
+            for (const tableName of tableList) {
+                const escapedTable = this.security.escapeIdentifier(tableName);
+                sqlDump += `-- --------------------------------------------------------\n`;
+                sqlDump += `-- Table structure for ${tableName}\n`;
+                sqlDump += `-- --------------------------------------------------------\n\n`;
+                // Add DROP TABLE IF EXISTS
+                if (include_drop) {
+                    sqlDump += `DROP TABLE IF EXISTS ${escapedTable};\n\n`;
+                }
+                // Get CREATE TABLE statement
+                const createQuery = `SHOW CREATE TABLE ${escapedTable}`;
+                const createResults = await this.db.query(createQuery);
+                queryCount++;
+                if (createResults.length > 0) {
+                    sqlDump += `${createResults[0]['Create Table']};\n\n`;
+                    backedUpTables.push(tableName);
+                }
+                // Get table data if requested
+                if (include_data) {
+                    const dataQuery = `SELECT * FROM ${escapedTable}`;
+                    const dataResults = await this.db.query(dataQuery);
+                    queryCount++;
+                    if (dataResults.length > 0) {
+                        totalRows += dataResults.length;
+                        const columns = Object.keys(dataResults[0]);
+                        const escapedColumns = columns.map(c => this.security.escapeIdentifier(c)).join(', ');
+                        sqlDump += `-- Data for table ${tableName}\n`;
+                        sqlDump += `LOCK TABLES ${escapedTable} WRITE;\n`;
+                        sqlDump += `/*!40000 ALTER TABLE ${escapedTable} DISABLE KEYS */;\n\n`;
+                        // Generate INSERT statements in batches
+                        const batchSize = 100;
+                        for (let i = 0; i < dataResults.length; i += batchSize) {
+                            const batch = dataResults.slice(i, i + batchSize);
+                            const values = batch.map(row => {
+                                const rowValues = columns.map(col => this.escapeValue(row[col]));
+                                return `(${rowValues.join(', ')})`;
+                            }).join(',\n');
+                            sqlDump += `INSERT INTO ${escapedTable} (${escapedColumns}) VALUES\n${values};\n\n`;
+                        }
+                        sqlDump += `/*!40000 ALTER TABLE ${escapedTable} ENABLE KEYS */;\n`;
+                        sqlDump += `UNLOCK TABLES;\n\n`;
+                    }
+                }
+            }
+            // Add footer
+            sqlDump += `COMMIT;\n`;
+            sqlDump += `SET FOREIGN_KEY_CHECKS=1;\n`;
+            sqlDump += `\n-- Dump completed successfully\n`;
+            return {
+                status: 'success',
+                data: {
+                    database: dbValidation.database,
+                    sql_dump: sqlDump,
+                    tables_backed_up: backedUpTables,
+                    table_count: backedUpTables.length,
+                    total_rows: totalRows,
+                    include_data: include_data,
+                    include_drop: include_drop
+                },
+                queryLog: this.db.getFormattedQueryLogs(queryCount)
+            };
+        }
+        catch (error) {
+            return {
+                status: 'error',
+                error: error.message,
+                queryLog: this.db.getFormattedQueryLogs(1)
+            };
+        }
+    }
+    /**
+     * Restore database from SQL dump
+     * Executes SQL statements from the provided SQL dump string
+     */
+    async restoreFromSql(params) {
+        try {
+            const { sql_dump, stop_on_error = true, database } = params;
+            // Validate database access
+            const dbValidation = this.validateDatabaseAccess(database);
+            if (!dbValidation.valid) {
+                return { status: 'error', error: dbValidation.error };
+            }
+            if (!sql_dump || sql_dump.trim().length === 0) {
+                return { status: 'error', error: 'SQL dump content is empty' };
+            }
+            // Parse SQL statements (split by semicolon, handling edge cases)
+            const statements = this.parseSqlStatements(sql_dump);
+            let successCount = 0;
+            let errorCount = 0;
+            const errors = [];
+            let queryCount = 0;
+            for (const statement of statements) {
+                const trimmed = statement.trim();
+                if (!trimmed || trimmed.startsWith('--') || trimmed.startsWith('/*')) {
+                    continue; // Skip comments and empty statements
+                }
+                try {
+                    await this.db.query(trimmed);
+                    queryCount++;
+                    successCount++;
+                }
+                catch (error) {
+                    errorCount++;
+                    errors.push({
+                        statement: trimmed.substring(0, 200) + (trimmed.length > 200 ? '...' : ''),
+                        error: error.message
+                    });
+                    if (stop_on_error) {
+                        return {
+                            status: 'error',
+                            error: `Restore stopped at error: ${error.message}`,
+                            data: {
+                                statements_executed: successCount,
+                                statements_failed: errorCount,
+                                errors: errors
+                            },
+                            queryLog: this.db.getFormattedQueryLogs(queryCount)
+                        };
+                    }
+                }
+            }
+            return {
+                status: errorCount > 0 ? 'partial' : 'success',
+                data: {
+                    message: errorCount > 0
+                        ? `Restore completed with ${errorCount} errors`
+                        : 'Restore completed successfully',
+                    statements_executed: successCount,
+                    statements_failed: errorCount,
+                    errors: errors.length > 0 ? errors : undefined
+                },
+                queryLog: this.db.getFormattedQueryLogs(queryCount)
+            };
+        }
+        catch (error) {
+            return {
+                status: 'error',
+                error: error.message,
+                queryLog: this.db.getFormattedQueryLogs(1)
+            };
+        }
+    }
+    /**
+     * Parse SQL dump into individual statements
+     */
+    parseSqlStatements(sqlDump) {
+        const statements = [];
+        let currentStatement = '';
+        let inString = false;
+        let stringChar = '';
+        let inComment = false;
+        let inBlockComment = false;
+        for (let i = 0; i < sqlDump.length; i++) {
+            const char = sqlDump[i];
+            const nextChar = sqlDump[i + 1];
+            const prevChar = sqlDump[i - 1];
+            // Handle block comments /* */
+            if (!inString && !inComment && char === '/' && nextChar === '*') {
+                inBlockComment = true;
+                currentStatement += char;
+                continue;
+            }
+            if (inBlockComment && char === '*' && nextChar === '/') {
+                inBlockComment = false;
+                currentStatement += char;
+                continue;
+            }
+            // Handle line comments --
+            if (!inString && !inBlockComment && char === '-' && nextChar === '-') {
+                inComment = true;
+                currentStatement += char;
+                continue;
+            }
+            if (inComment && char === '\n') {
+                inComment = false;
+                currentStatement += char;
+                continue;
+            }
+            // Handle strings
+            if (!inComment && !inBlockComment && (char === "'" || char === '"')) {
+                if (!inString) {
+                    inString = true;
+                    stringChar = char;
+                }
+                else if (char === stringChar && prevChar !== '\\') {
+                    inString = false;
+                }
+            }
+            // Handle statement terminator
+            if (!inString && !inComment && !inBlockComment && char === ';') {
+                currentStatement += char;
+                const trimmed = currentStatement.trim();
+                if (trimmed && !trimmed.startsWith('--')) {
+                    statements.push(trimmed);
+                }
+                currentStatement = '';
+                continue;
+            }
+            currentStatement += char;
+        }
+        // Add any remaining statement
+        const trimmed = currentStatement.trim();
+        if (trimmed && !trimmed.startsWith('--') && trimmed !== '') {
+            statements.push(trimmed);
+        }
+        return statements;
+    }
+    /**
+     * Get database schema overview (all CREATE statements)
+     */
+    async getDatabaseSchema(params) {
+        try {
+            const { database, include_views = true, include_procedures = true, include_functions = true, include_triggers = true } = params;
+            // Validate database access
+            const dbValidation = this.validateDatabaseAccess(database);
+            if (!dbValidation.valid) {
+                return { status: 'error', error: dbValidation.error };
+            }
+            const schema = {
+                database: dbValidation.database,
+                tables: [],
+                views: [],
+                procedures: [],
+                functions: [],
+                triggers: []
+            };
+            let queryCount = 0;
+            // Get tables
+            const tablesQuery = `SHOW FULL TABLES WHERE Table_type = 'BASE TABLE'`;
+            const tablesResult = await this.db.query(tablesQuery);
+            queryCount++;
+            for (const row of tablesResult) {
+                const tableName = Object.values(row)[0];
+                const createQuery = `SHOW CREATE TABLE ${this.security.escapeIdentifier(tableName)}`;
+                const createResult = await this.db.query(createQuery);
+                queryCount++;
+                if (createResult.length > 0) {
+                    schema.tables.push({
+                        name: tableName,
+                        create_statement: createResult[0]['Create Table']
+                    });
+                }
+            }
+            // Get views
+            if (include_views) {
+                const viewsQuery = `SHOW FULL TABLES WHERE Table_type = 'VIEW'`;
+                const viewsResult = await this.db.query(viewsQuery);
+                queryCount++;
+                for (const row of viewsResult) {
+                    const viewName = Object.values(row)[0];
+                    const createQuery = `SHOW CREATE VIEW ${this.security.escapeIdentifier(viewName)}`;
+                    const createResult = await this.db.query(createQuery);
+                    queryCount++;
+                    if (createResult.length > 0) {
+                        schema.views.push({
+                            name: viewName,
+                            create_statement: createResult[0]['Create View']
+                        });
+                    }
+                }
+            }
+            // Get procedures
+            if (include_procedures) {
+                const procsQuery = `SHOW PROCEDURE STATUS WHERE Db = ?`;
+                const procsResult = await this.db.query(procsQuery, [dbValidation.database]);
+                queryCount++;
+                for (const proc of procsResult) {
+                    try {
+                        const createQuery = `SHOW CREATE PROCEDURE ${this.security.escapeIdentifier(proc.Name)}`;
+                        const createResult = await this.db.query(createQuery);
+                        queryCount++;
+                        if (createResult.length > 0) {
+                            schema.procedures.push({
+                                name: proc.Name,
+                                create_statement: createResult[0]['Create Procedure']
+                            });
+                        }
+                    }
+                    catch (e) {
+                        // Skip if we can't get the procedure definition
+                    }
+                }
+            }
+            // Get functions
+            if (include_functions) {
+                const funcsQuery = `SHOW FUNCTION STATUS WHERE Db = ?`;
+                const funcsResult = await this.db.query(funcsQuery, [dbValidation.database]);
+                queryCount++;
+                for (const func of funcsResult) {
+                    try {
+                        const createQuery = `SHOW CREATE FUNCTION ${this.security.escapeIdentifier(func.Name)}`;
+                        const createResult = await this.db.query(createQuery);
+                        queryCount++;
+                        if (createResult.length > 0) {
+                            schema.functions.push({
+                                name: func.Name,
+                                create_statement: createResult[0]['Create Function']
+                            });
+                        }
+                    }
+                    catch (e) {
+                        // Skip if we can't get the function definition
+                    }
+                }
+            }
+            // Get triggers
+            if (include_triggers) {
+                const triggersQuery = `SHOW TRIGGERS`;
+                const triggersResult = await this.db.query(triggersQuery);
+                queryCount++;
+                for (const trigger of triggersResult) {
+                    try {
+                        const createQuery = `SHOW CREATE TRIGGER ${this.security.escapeIdentifier(trigger.Trigger)}`;
+                        const createResult = await this.db.query(createQuery);
+                        queryCount++;
+                        if (createResult.length > 0) {
+                            schema.triggers.push({
+                                name: trigger.Trigger,
+                                create_statement: createResult[0]['SQL Original Statement']
+                            });
+                        }
+                    }
+                    catch (e) {
+                        // Skip if we can't get the trigger definition
+                    }
+                }
+            }
+            return {
+                status: 'success',
+                data: schema,
+                queryLog: this.db.getFormattedQueryLogs(queryCount)
+            };
+        }
+        catch (error) {
+            return {
+                status: 'error',
+                error: error.message,
+                queryLog: this.db.getFormattedQueryLogs(1)
+            };
+        }
+    }
+}
+exports.BackupRestoreTools = BackupRestoreTools;

package/dist/tools/dataExportTools.d.ts

@@ -1,9 +1,17 @@
-import { FilterCondition, Pagination, Sorting } from '../validation/schemas';
-import SecurityLayer from '../security/securityLayer';
+import { FilterCondition, Pagination, Sorting } from "../validation/schemas";
+import SecurityLayer from "../security/securityLayer";
 export declare class DataExportTools {
     private db;
     private security;
     constructor(security: SecurityLayer);
+    /**
+     * Validate database access
+     */
+    private validateDatabaseAccess;
+    /**
+     * Escape string value for SQL INSERT statements
+     */
+    private escapeValue;
     /**
      * Export table data to CSV format
      */
@@ -32,4 +40,85 @@ export declare class DataExportTools {
         error?: string;
         queryLog?: string;
     }>;
+    /**
+     * Export table data to JSON format
+     */
+    exportTableToJSON(params: {
+        table_name: string;
+        filters?: FilterCondition[];
+        pagination?: Pagination;
+        sorting?: Sorting;
+        pretty?: boolean;
+        database?: string;
+    }): Promise<{
+        status: string;
+        data?: any;
+        error?: string;
+        queryLog?: string;
+    }>;
+    /**
+     * Export query results to JSON format
+     */
+    exportQueryToJSON(params: {
+        query: string;
+        params?: any[];
+        pretty?: boolean;
+    }): Promise<{
+        status: string;
+        data?: any;
+        error?: string;
+        queryLog?: string;
+    }>;
+    /**
+     * Export table data to SQL INSERT statements
+     */
+    exportTableToSql(params: {
+        table_name: string;
+        filters?: FilterCondition[];
+        include_create_table?: boolean;
+        batch_size?: number;
+        database?: string;
+    }): Promise<{
+        status: string;
+        data?: any;
+        error?: string;
+        queryLog?: string;
+    }>;
+    /**
+     * Import data from CSV string
+     */
+    importFromCSV(params: {
+        table_name: string;
+        csv_data: string;
+        has_headers?: boolean;
+        column_mapping?: Record<string, string>;
+        skip_errors?: boolean;
+        batch_size?: number;
+        database?: string;
+    }): Promise<{
+        status: string;
+        data?: any;
+        error?: string;
+        queryLog?: string;
+    }>;
+    /**
+     * Parse CSV string into array of arrays
+     */
+    private parseCSV;
+    /**
+     * Import data from JSON string
+     */
+    importFromJSON(params: {
+        table_name: string;
+        json_data: string;
+        column_mapping?: Record<string, string>;
+        skip_errors?: boolean;
+        batch_size?: number;
+        database?: string;
+    }): Promise<{
+        status: string;
+        data?: any;
+        error?: string;
+        queryLog?: string;
+    }>;
 }