@berthojoris/mcp-mysql-server 1.4.15 → 1.6.0

package/README.md

@@ -463,7 +463,7 @@ After (DDL enabled):
 
 ## 🛠️ Available Tools
 
-The MCP server provides **30 powerful tools**:
+The MCP server provides **72 powerful tools**:
 
 ### Database Discovery (4 tools)
 
@@ -485,9 +485,7 @@ The MCP server provides **30 powerful tools**:
 
 ### Bulk Operations (3 tools)
 
-| Tool | Description | 
-
-| Performance |
+| Tool | Description | Performance |
 |------|-------------|-------------|
 | `bulk_insert` | Insert multiple records in batches for optimal performance | Up to 10,000 records per batch |
 | `bulk_update` | Update multiple records with different conditions in batches | Up to 1,000 operations per batch |
@@ -528,7 +526,7 @@ The MCP server provides **30 powerful tools**:
 | `get_transaction_status` | Check if a transaction is active |
 | `execute_in_transaction` | Execute SQL within a transaction context |
 
-### Stored Procedures (5 tools)
+### Stored Procedures (6 tools)
 
 | Tool | Description | Requires |
 |------|-------------|----------|
@@ -537,6 +535,105 @@ The MCP server provides **30 powerful tools**:
 | `get_stored_procedure_info` | Get detailed information about a stored procedure | `procedure` permission |
 | `execute_stored_procedure` | Execute stored procedures with IN/OUT/INOUT parameters | `procedure` permission |
 | `drop_stored_procedure` | Delete stored procedures | `procedure` permission |
+| `show_create_procedure` | Show CREATE statement for a stored procedure | `procedure` permission |
+
+### Views Management (6 tools) - NEW!
+
+| Tool | Description | Requires |
+|------|-------------|----------|
+| `list_views` | List all views in the database | `list` permission |
+| `get_view_info` | Get detailed information about a view | `list` permission |
+| `create_view` | Create a new view with SELECT definition | `ddl` permission |
+| `alter_view` | Alter an existing view definition | `ddl` permission |
+| `drop_view` | Drop a view | `ddl` permission |
+| `show_create_view` | Show CREATE statement for a view | `list` permission |
+
+### Triggers Management (5 tools) - NEW!
+
+| Tool | Description | Requires |
+|------|-------------|----------|
+| `list_triggers` | List all triggers in the database | `list` permission |
+| `get_trigger_info` | Get detailed information about a trigger | `list` permission |
+| `create_trigger` | Create a new trigger on a table | `ddl` permission |
+| `drop_trigger` | Drop a trigger | `ddl` permission |
+| `show_create_trigger` | Show CREATE statement for a trigger | `list` permission |
+
+### Functions Management (6 tools) - NEW!
+
+| Tool | Description | Requires |
+|------|-------------|----------|
+| `list_functions` | List all user-defined functions | `list` permission |
+| `get_function_info` | Get detailed information about a function | `list` permission |
+| `create_function` | Create a new user-defined function | `ddl` permission |
+| `drop_function` | Drop a function | `ddl` permission |
+| `show_create_function` | Show CREATE statement for a function | `list` permission |
+| `execute_function` | Execute a function and return its result | `read` permission |
+
+### Index Management (5 tools) - NEW!
+
+| Tool | Description | Requires |
+|------|-------------|----------|
+| `list_indexes` | List all indexes for a table | `list` permission |
+| `get_index_info` | Get detailed information about an index | `list` permission |
+| `create_index` | Create a new index (BTREE, HASH, FULLTEXT, SPATIAL) | `ddl` permission |
+| `drop_index` | Drop an index from a table | `ddl` permission |
+| `analyze_index` | Analyze index statistics | `utility` permission |
+
+### Constraint Management (7 tools) - NEW!
+
+| Tool | Description | Requires |
+|------|-------------|----------|
+| `list_foreign_keys` | List all foreign keys for a table | `list` permission |
+| `list_constraints` | List all constraints (PK, FK, UNIQUE, CHECK) | `list` permission |
+| `add_foreign_key` | Add a foreign key constraint | `ddl` permission |
+| `drop_foreign_key` | Drop a foreign key constraint | `ddl` permission |
+| `add_unique_constraint` | Add a unique constraint | `ddl` permission |
+| `drop_constraint` | Drop a UNIQUE or CHECK constraint | `ddl` permission |
+| `add_check_constraint` | Add a CHECK constraint (MySQL 8.0.16+) | `ddl` permission |
+
+### Table Maintenance (8 tools) - NEW!
+
+| Tool | Description | Requires |
+|------|-------------|----------|
+| `analyze_table` | Update index statistics for optimizer | `utility` permission |
+| `optimize_table` | Reclaim unused space and defragment | `utility` permission |
+| `check_table` | Check table for errors | `utility` permission |
+| `repair_table` | Repair corrupted table (MyISAM, ARCHIVE, CSV) | `utility` permission |
+| `truncate_table` | Remove all rows quickly | `ddl` permission |
+| `get_table_status` | Get detailed table status and statistics | `list` permission |
+| `flush_table` | Close and reopen table(s) | `utility` permission |
+| `get_table_size` | Get size information for tables | `list` permission |
+
+### Process & Server Management (9 tools) - NEW!
+
+| Tool | Description | Requires |
+|------|-------------|----------|
+| `show_process_list` | Show all running MySQL processes | `utility` permission |
+| `kill_process` | Kill a MySQL process/connection | `utility` permission |
+| `show_status` | Show MySQL server status variables | `utility` permission |
+| `show_variables` | Show MySQL server configuration variables | `utility` permission |
+| `explain_query` | Show query execution plan (EXPLAIN) | `utility` permission |
+| `show_engine_status` | Show storage engine status (InnoDB) | `utility` permission |
+| `get_server_info` | Get comprehensive server information | `utility` permission |
+| `show_binary_logs` | Show binary log files | `utility` permission |
+| `show_replication_status` | Show replication status | `utility` permission |
+
+### Cache Management (5 tools)
+
+| Tool | Description |
+|------|-------------|
+| `get_cache_stats` | Get query cache statistics |
+| `get_cache_config` | Get current cache configuration |
+| `configure_cache` | Configure cache settings (TTL, max size) |
+| `clear_cache` | Clear all cached query results |
+| `invalidate_table_cache` | Invalidate cache for a specific table |
+
+### Query Optimization (2 tools)
+
+| Tool | Description |
+|------|-------------|
+| `analyze_query` | Analyze query and get optimization suggestions |
+| `get_optimization_hints` | Get optimizer hints for SPEED, MEMORY, or STABILITY goals |
 
 ---
 

package/dist/cache/queryCache.d.ts

@@ -0,0 +1,126 @@
+/**
+ * Cache entry interface
+ */
+export interface CacheEntry {
+    data: any;
+    timestamp: number;
+    hitCount: number;
+    queryHash: string;
+    sql: string;
+    params?: any[];
+}
+/**
+ * Cache statistics interface
+ */
+export interface CacheStats {
+    totalHits: number;
+    totalMisses: number;
+    hitRate: number;
+    currentSize: number;
+    maxSize: number;
+    ttlMs: number;
+    enabled: boolean;
+}
+/**
+ * Cache configuration interface
+ */
+export interface CacheConfig {
+    enabled: boolean;
+    ttlMs: number;
+    maxSize: number;
+    maxMemoryMB: number;
+}
+/**
+ * LRU Query Cache with TTL support
+ * Implements an in-memory cache for query results to improve performance
+ */
+export declare class QueryCache {
+    private static instance;
+    private cache;
+    private config;
+    private stats;
+    private accessOrder;
+    private constructor();
+    /**
+     * Get singleton instance
+     */
+    static getInstance(): QueryCache;
+    /**
+     * Load cache configuration from environment variables
+     */
+    private loadConfigFromEnv;
+    /**
+     * Generate a unique hash for a query and its parameters
+     */
+    private generateHash;
+    /**
+     * Check if a query result is cached and valid
+     */
+    get(sql: string, params?: any[]): CacheEntry | null;
+    /**
+     * Cache a query result
+     */
+    set(sql: string, params: any[] | undefined, data: any): void;
+    /**
+     * Invalidate cache entries matching a pattern
+     * Used when data is modified (INSERT, UPDATE, DELETE)
+     */
+    invalidate(pattern?: string | RegExp): number;
+    /**
+     * Escape special regex characters in a string
+     */
+    private escapeRegex;
+    /**
+     * Invalidate cache entries related to a specific table
+     */
+    invalidateTable(tableName: string): number;
+    /**
+     * Evict least recently used entries if cache is full
+     */
+    private evictIfNeeded;
+    /**
+     * Update access order for LRU tracking
+     */
+    private updateAccessOrder;
+    /**
+     * Remove hash from access order
+     */
+    private removeFromAccessOrder;
+    /**
+     * Estimate memory usage of the cache
+     */
+    private estimateMemoryUsage;
+    /**
+     * Get cache statistics
+     */
+    getStats(): CacheStats;
+    /**
+     * Get current cache configuration
+     */
+    getConfig(): CacheConfig;
+    /**
+     * Update cache configuration
+     */
+    setConfig(config: Partial<CacheConfig>): void;
+    /**
+     * Enable caching
+     */
+    enable(): void;
+    /**
+     * Disable caching
+     */
+    disable(): void;
+    /**
+     * Clear all cache entries
+     */
+    clear(): void;
+    /**
+     * Reset statistics
+     */
+    resetStats(): void;
+    /**
+     * Get all cached entries (for debugging)
+     */
+    getAllEntries(): CacheEntry[];
+}
+export default QueryCache;

package/dist/cache/queryCache.js

@@ -0,0 +1,337 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QueryCache = void 0;
+const crypto_1 = __importDefault(require("crypto"));
+/**
+ * Default cache configuration
+ */
+const DEFAULT_CONFIG = {
+    enabled: true,
+    ttlMs: 60000, // 1 minute default TTL
+    maxSize: 100, // Maximum 100 cached queries
+    maxMemoryMB: 50, // Maximum 50MB memory usage
+};
+/**
+ * LRU Query Cache with TTL support
+ * Implements an in-memory cache for query results to improve performance
+ */
+class QueryCache {
+    constructor() {
+        this.cache = new Map();
+        this.config = { ...DEFAULT_CONFIG };
+        this.stats = { totalHits: 0, totalMisses: 0 };
+        this.accessOrder = [];
+        // Load config from environment if available
+        this.loadConfigFromEnv();
+    }
+    /**
+     * Get singleton instance
+     */
+    static getInstance() {
+        if (!QueryCache.instance) {
+            QueryCache.instance = new QueryCache();
+        }
+        return QueryCache.instance;
+    }
+    /**
+     * Load cache configuration from environment variables
+     */
+    loadConfigFromEnv() {
+        if (process.env.CACHE_ENABLED !== undefined) {
+            this.config.enabled = process.env.CACHE_ENABLED === "true";
+        }
+        if (process.env.CACHE_TTL_MS) {
+            const ttl = parseInt(process.env.CACHE_TTL_MS, 10);
+            if (!isNaN(ttl) && ttl > 0) {
+                this.config.ttlMs = ttl;
+            }
+        }
+        if (process.env.CACHE_MAX_SIZE) {
+            const maxSize = parseInt(process.env.CACHE_MAX_SIZE, 10);
+            if (!isNaN(maxSize) && maxSize > 0) {
+                this.config.maxSize = maxSize;
+            }
+        }
+        if (process.env.CACHE_MAX_MEMORY_MB) {
+            const maxMemory = parseInt(process.env.CACHE_MAX_MEMORY_MB, 10);
+            if (!isNaN(maxMemory) && maxMemory > 0) {
+                this.config.maxMemoryMB = maxMemory;
+            }
+        }
+    }
+    /**
+     * Generate a unique hash for a query and its parameters
+     */
+    generateHash(sql, params) {
+        const normalized = sql.trim().toLowerCase();
+        let paramsStr = "";
+        if (params) {
+            try {
+                paramsStr = JSON.stringify(params);
+            }
+            catch {
+                // Handle circular references or non-serializable values
+                paramsStr = params
+                    .map((p) => {
+                    if (p === null)
+                        return "null";
+                    if (p === undefined)
+                        return "undefined";
+                    if (typeof p === "object") {
+                        try {
+                            return JSON.stringify(p);
+                        }
+                        catch {
+                            return String(p);
+                        }
+                    }
+                    return String(p);
+                })
+                    .join(",");
+            }
+        }
+        const combined = `${normalized}:${paramsStr}`;
+        return crypto_1.default.createHash("md5").update(combined).digest("hex");
+    }
+    /**
+     * Check if a query result is cached and valid
+     */
+    get(sql, params) {
+        if (!this.config.enabled) {
+            return null;
+        }
+        const hash = this.generateHash(sql, params);
+        const entry = this.cache.get(hash);
+        if (!entry) {
+            this.stats.totalMisses++;
+            return null;
+        }
+        // Check if entry has expired
+        const now = Date.now();
+        if (now - entry.timestamp > this.config.ttlMs) {
+            this.cache.delete(hash);
+            this.removeFromAccessOrder(hash);
+            this.stats.totalMisses++;
+            return null;
+        }
+        // Update hit count and access order
+        entry.hitCount++;
+        this.updateAccessOrder(hash);
+        this.stats.totalHits++;
+        // Return a deep copy to prevent mutation of cached data
+        return {
+            ...entry,
+            data: JSON.parse(JSON.stringify(entry.data)),
+        };
+    }
+    /**
+     * Cache a query result
+     */
+    set(sql, params, data) {
+        if (!this.config.enabled) {
+            return;
+        }
+        // Only cache SELECT queries
+        const normalizedSql = sql.trim().toUpperCase();
+        if (!normalizedSql.startsWith("SELECT")) {
+            return;
+        }
+        const hash = this.generateHash(sql, params);
+        // Check if we need to evict entries
+        this.evictIfNeeded();
+        const entry = {
+            data,
+            timestamp: Date.now(),
+            hitCount: 0,
+            queryHash: hash,
+            sql,
+            params,
+        };
+        this.cache.set(hash, entry);
+        this.updateAccessOrder(hash);
+    }
+    /**
+     * Invalidate cache entries matching a pattern
+     * Used when data is modified (INSERT, UPDATE, DELETE)
+     */
+    invalidate(pattern) {
+        let invalidatedCount = 0;
+        if (!pattern) {
+            // Clear all cache
+            invalidatedCount = this.cache.size;
+            this.cache.clear();
+            this.accessOrder = [];
+            return invalidatedCount;
+        }
+        const regex = typeof pattern === "string" ? new RegExp(pattern, "i") : pattern;
+        for (const [hash, entry] of this.cache.entries()) {
+            if (regex.test(entry.sql)) {
+                this.cache.delete(hash);
+                this.removeFromAccessOrder(hash);
+                invalidatedCount++;
+            }
+        }
+        return invalidatedCount;
+    }
+    /**
+     * Escape special regex characters in a string
+     */
+    escapeRegex(str) {
+        return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    }
+    /**
+     * Invalidate cache entries related to a specific table
+     */
+    invalidateTable(tableName) {
+        // Escape special regex characters in table name to prevent regex injection
+        const escapedTableName = this.escapeRegex(tableName);
+        // Match table name in various SQL patterns
+        const patterns = [
+            new RegExp(`\\bFROM\\s+[\`"']?${escapedTableName}[\`"']?\\b`, "i"),
+            new RegExp(`\\bJOIN\\s+[\`"']?${escapedTableName}[\`"']?\\b`, "i"),
+            new RegExp(`\\b${escapedTableName}\\b`, "i"),
+        ];
+        let invalidatedCount = 0;
+        for (const [hash, entry] of this.cache.entries()) {
+            for (const pattern of patterns) {
+                if (pattern.test(entry.sql)) {
+                    this.cache.delete(hash);
+                    this.removeFromAccessOrder(hash);
+                    invalidatedCount++;
+                    break;
+                }
+            }
+        }
+        return invalidatedCount;
+    }
+    /**
+     * Evict least recently used entries if cache is full
+     */
+    evictIfNeeded() {
+        // Check size limit
+        while (this.cache.size >= this.config.maxSize &&
+            this.accessOrder.length > 0) {
+            const lruHash = this.accessOrder.shift();
+            if (lruHash) {
+                this.cache.delete(lruHash);
+            }
+        }
+        // Check memory limit (approximate) - recalculate each iteration
+        const maxMemoryBytes = this.config.maxMemoryMB * 1024 * 1024;
+        while (this.estimateMemoryUsage() > maxMemoryBytes &&
+            this.accessOrder.length > 0) {
+            const lruHash = this.accessOrder.shift();
+            if (lruHash) {
+                this.cache.delete(lruHash);
+            }
+        }
+        // Also evict expired entries
+        const now = Date.now();
+        const expiredHashes = [];
+        for (const [hash, entry] of this.cache.entries()) {
+            if (now - entry.timestamp > this.config.ttlMs) {
+                expiredHashes.push(hash);
+            }
+        }
+        // Delete after iteration to avoid modifying map during iteration
+        for (const hash of expiredHashes) {
+            this.cache.delete(hash);
+            this.removeFromAccessOrder(hash);
+        }
+    }
+    /**
+     * Update access order for LRU tracking
+     */
+    updateAccessOrder(hash) {
+        this.removeFromAccessOrder(hash);
+        this.accessOrder.push(hash);
+    }
+    /**
+     * Remove hash from access order
+     */
+    removeFromAccessOrder(hash) {
+        const index = this.accessOrder.indexOf(hash);
+        if (index > -1) {
+            this.accessOrder.splice(index, 1);
+        }
+    }
+    /**
+     * Estimate memory usage of the cache
+     */
+    estimateMemoryUsage() {
+        let totalSize = 0;
+        for (const [, entry] of this.cache.entries()) {
+            totalSize += JSON.stringify(entry).length * 2; // UTF-16 encoding
+        }
+        return totalSize;
+    }
+    /**
+     * Get cache statistics
+     */
+    getStats() {
+        const totalRequests = this.stats.totalHits + this.stats.totalMisses;
+        return {
+            totalHits: this.stats.totalHits,
+            totalMisses: this.stats.totalMisses,
+            hitRate: totalRequests > 0 ? this.stats.totalHits / totalRequests : 0,
+            currentSize: this.cache.size,
+            maxSize: this.config.maxSize,
+            ttlMs: this.config.ttlMs,
+            enabled: this.config.enabled,
+        };
+    }
+    /**
+     * Get current cache configuration
+     */
+    getConfig() {
+        return { ...this.config };
+    }
+    /**
+     * Update cache configuration
+     */
+    setConfig(config) {
+        this.config = { ...this.config, ...config };
+        // If cache is disabled, clear it
+        if (!this.config.enabled) {
+            this.clear();
+        }
+    }
+    /**
+     * Enable caching
+     */
+    enable() {
+        this.config.enabled = true;
+    }
+    /**
+     * Disable caching
+     */
+    disable() {
+        this.config.enabled = false;
+        this.clear();
+    }
+    /**
+     * Clear all cache entries
+     */
+    clear() {
+        this.cache.clear();
+        this.accessOrder = [];
+    }
+    /**
+     * Reset statistics
+     */
+    resetStats() {
+        this.stats.totalHits = 0;
+        this.stats.totalMisses = 0;
+    }
+    /**
+     * Get all cached entries (for debugging)
+     */
+    getAllEntries() {
+        return Array.from(this.cache.values());
+    }
+}
+exports.QueryCache = QueryCache;
+exports.default = QueryCache;