@berthojoris/mcp-mysql-server 1.35.0 → 1.36.0

package/dist/tools/dataExportTools.js

@@ -222,81 +222,6 @@ class DataExportTools {
             };
         }
     }
-    /**
-     * Export query results to CSV format
-     */
-    async exportQueryToCSV(params) {
-        try {
-            const { query, params: queryParams = [], include_headers = true, } = params;
-            // Validate query is a SELECT statement
-            if (!this.security.isReadOnlyQuery(query)) {
-                return {
-                    status: "error",
-                    error: "Only SELECT queries can be exported to CSV",
-                };
-            }
-            // Validate parameters
-            const paramValidation = this.security.validateParameters(queryParams);
-            if (!paramValidation.valid) {
-                return {
-                    status: "error",
-                    error: paramValidation.error,
-                };
-            }
-            // Execute query
-            const results = await this.db.query(query, queryParams);
-            // If no results, return empty CSV
-            if (results.length === 0) {
-                return {
-                    status: "success",
-                    data: {
-                        csv: include_headers ? "" : "",
-                        row_count: 0,
-                    },
-                };
-            }
-            // Generate CSV
-            let csv = "";
-            // Add headers if requested
-            if (include_headers) {
-                const headers = Object.keys(results[0]).join(",");
-                csv += headers + "\n";
-            }
-            // Add data rows
-            for (const row of results) {
-                const values = Object.values(row)
-                    .map((value) => {
-                    if (value === null)
-                        return "";
-                    if (typeof value === "string") {
-                        // Escape quotes and wrap in quotes if contains comma or newline
-                        if (value.includes(",") ||
-                            value.includes("\n") ||
-                            value.includes('"')) {
-                            return `"${value.replace(/"/g, '""')}"`;
-                        }
-                        return value;
-                    }
-                    return String(value);
-                })
-                    .join(",");
-                csv += values + "\n";
-            }
-            return {
-                status: "success",
-                data: {
-                    csv: csv,
-                    row_count: results.length,
-                },
-            };
-        }
-        catch (error) {
-            return {
-                status: "error",
-                error: error.message,
-            };
-        }
-    }
     /**
      * Export table data to JSON format
      */
@@ -424,179 +349,6 @@ class DataExportTools {
             };
         }
     }
-    /**
-     * Export query results to JSON format
-     */
-    async exportQueryToJSON(params) {
-        try {
-            const { query, params: queryParams = [], pretty = true } = params;
-            // Validate query is a SELECT statement
-            if (!this.security.isReadOnlyQuery(query)) {
-                return {
-                    status: "error",
-                    error: "Only SELECT queries can be exported to JSON",
-                };
-            }
-            // Validate parameters
-            const paramValidation = this.security.validateParameters(queryParams);
-            if (!paramValidation.valid) {
-                return { status: "error", error: paramValidation.error };
-            }
-            // Execute query
-            const results = await this.db.query(query, queryParams);
-            // Generate JSON
-            const json = pretty
-                ? JSON.stringify(results, null, 2)
-                : JSON.stringify(results);
-            return {
-                status: "success",
-                data: {
-                    json: json,
-                    row_count: results.length,
-                },
-            };
-        }
-        catch (error) {
-            return {
-                status: "error",
-                error: error.message,
-            };
-        }
-    }
-    /**
-     * Export table data to SQL INSERT statements
-     */
-    async exportTableToSql(params) {
-        try {
-            const { table_name, filters = [], include_create_table = false, batch_size = 100, 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 escapedTableName = this.security.escapeIdentifier(table_name);
-            let sql = "";
-            let queryCount = 0;
-            // Add CREATE TABLE if requested
-            if (include_create_table) {
-                const createQuery = `SHOW CREATE TABLE ${escapedTableName}`;
-                const createResults = await this.db.query(createQuery);
-                queryCount++;
-                if (createResults.length > 0) {
-                    sql += `-- Table structure for ${table_name}\n`;
-                    sql += `${createResults[0]["Create Table"]};\n\n`;
-                }
-            }
-            // Build WHERE clause
-            let whereClause = "";
-            const whereParams = [];
-            if (filters && filters.length > 0) {
-                const whereConditions = [];
-                for (const filter of filters) {
-                    const fieldValidation = this.security.validateIdentifier(filter.field);
-                    if (!fieldValidation.valid) {
-                        return {
-                            status: "error",
-                            error: `Invalid field name: ${filter.field}`,
-                        };
-                    }
-                    const fieldName = this.security.escapeIdentifier(filter.field);
-                    switch (filter.operator) {
-                        case "eq":
-                            whereConditions.push(`${fieldName} = ?`);
-                            whereParams.push(filter.value);
-                            break;
-                        case "neq":
-                            whereConditions.push(`${fieldName} != ?`);
-                            whereParams.push(filter.value);
-                            break;
-                        case "gt":
-                            whereConditions.push(`${fieldName} > ?`);
-                            whereParams.push(filter.value);
-                            break;
-                        case "gte":
-                            whereConditions.push(`${fieldName} >= ?`);
-                            whereParams.push(filter.value);
-                            break;
-                        case "lt":
-                            whereConditions.push(`${fieldName} < ?`);
-                            whereParams.push(filter.value);
-                            break;
-                        case "lte":
-                            whereConditions.push(`${fieldName} <= ?`);
-                            whereParams.push(filter.value);
-                            break;
-                        case "like":
-                            whereConditions.push(`${fieldName} LIKE ?`);
-                            whereParams.push(filter.value);
-                            break;
-                        case "in":
-                            if (Array.isArray(filter.value)) {
-                                const placeholders = filter.value.map(() => "?").join(", ");
-                                whereConditions.push(`${fieldName} IN (${placeholders})`);
-                                whereParams.push(...filter.value);
-                            }
-                            else {
-                                return {
-                                    status: "error",
-                                    error: "IN operator requires an array of values",
-                                };
-                            }
-                            break;
-                        default:
-                            return {
-                                status: "error",
-                                error: `Unsupported operator: ${filter.operator}`,
-                            };
-                    }
-                }
-                if (whereConditions.length > 0) {
-                    whereClause = "WHERE " + whereConditions.join(" AND ");
-                }
-            }
-            // Get data
-            const dataQuery = `SELECT * FROM ${escapedTableName} ${whereClause}`;
-            const results = await this.db.query(dataQuery, whereParams);
-            queryCount++;
-            if (results.length > 0) {
-                const columns = Object.keys(results[0]);
-                const escapedColumns = columns
-                    .map((c) => this.security.escapeIdentifier(c))
-                    .join(", ");
-                sql += `-- Data for table ${table_name} (${results.length} rows)\n`;
-                // Generate INSERT statements in batches
-                for (let i = 0; i < results.length; i += batch_size) {
-                    const batch = results.slice(i, i + batch_size);
-                    const values = batch
-                        .map((row) => {
-                        const rowValues = columns.map((col) => this.escapeValue(row[col]));
-                        return `(${rowValues.join(", ")})`;
-                    })
-                        .join(",\n");
-                    sql += `INSERT INTO ${escapedTableName} (${escapedColumns}) VALUES\n${values};\n\n`;
-                }
-            }
-            return {
-                status: "success",
-                data: {
-                    sql: sql,
-                    row_count: results.length,
-                    table_name: table_name,
-                },
-            };
-        }
-        catch (error) {
-            return {
-                status: "error",
-                error: error.message,
-            };
-        }
-    }
     /**
      * Import data from CSV string
      */

package/dist/tools/migrationTools.d.ts

@@ -15,77 +15,4 @@ export declare class MigrationTools {
      * Escape string value for SQL
      */
     private escapeValue;
-    /**
-     * Copy data from one table to another within the same database
-     */
-    copyTableData(params: {
-        source_table: string;
-        target_table: string;
-        column_mapping?: Record<string, string>;
-        where_clause?: string;
-        truncate_target?: boolean;
-        batch_size?: number;
-        database?: string;
-    }): Promise<{
-        status: string;
-        data?: any;
-        error?: string;
-    }>;
-    /**
-     * Move data from one table to another (copy + delete from source)
-     */
-    moveTableData(params: {
-        source_table: string;
-        target_table: string;
-        column_mapping?: Record<string, string>;
-        where_clause?: string;
-        batch_size?: number;
-        database?: string;
-    }): Promise<{
-        status: string;
-        data?: any;
-        error?: string;
-    }>;
-    /**
-     * Clone a table structure (with or without data)
-     */
-    cloneTable(params: {
-        source_table: string;
-        new_table_name: string;
-        include_data?: boolean;
-        include_indexes?: boolean;
-        database?: string;
-    }): Promise<{
-        status: string;
-        data?: any;
-        error?: string;
-    }>;
-    /**
-     * Compare structure of two tables
-     */
-    compareTableStructure(params: {
-        table1: string;
-        table2: string;
-        database?: string;
-    }): Promise<{
-        status: string;
-        data?: any;
-        error?: string;
-    }>;
-    /**
-     * Sync data between two tables based on a key column
-     */
-    syncTableData(params: {
-        source_table: string;
-        target_table: string;
-        key_column: string;
-        columns_to_sync?: string[];
-        sync_mode?: "insert_only" | "update_only" | "upsert";
-        batch_size?: number;
-        database?: string;
-    }): Promise<{
-        status: string;
-        data?: any;
-        error?: string;
-    }>;
 }