@berthojoris/mcp-mysql-server 1.28.0 → 1.30.0

package/CHANGELOG.md

@@ -5,6 +5,30 @@ All notable changes to the MySQL MCP Server will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [1.30.0] - 2025-12-22
+
+### Fixed
+- **Security Layer Comment Detection** - Fixed overly aggressive regex patterns that incorrectly flagged legitimate SQL syntax:
+  - Fixed `/\/*/` pattern that incorrectly matched forward slashes in function calls like `YEAR(start_date)`
+  - Improved `--` pattern to `--\s` to avoid false positives with date formats
+  - Now properly detects actual comment patterns while allowing legitimate SQL syntax
+  - Resolves issue where valid SELECT queries with date functions were being rejected
+
+## [1.29.0] - 2025-12-21
+
+### Enhanced
+- **`get_database_summary` tool** - Significantly improved output format and functionality:
+  - Added database **Overview section** displaying total tables, tables shown, and total estimated rows with thousands separators
+  - Enhanced **column display**: now one per line with data type, nullable status, and key indicators (PK, UNI, FK with target table)
+  - Added **Primary Key section** per table showing all PK columns
+  - Included **Foreign Key relationships** section showing all FK connections across tables (can be disabled with `include_relationships: false`)
+  - Added `max_tables` parameter (max 500) to limit output for large databases
+  - Added `include_relationships` parameter (default: true) to control FK relationships display
+  - Improved **markdown formatting** with clear hierarchy using H1, H2, H3 headings
+  - Enhanced **foreign key tracking**: shows FK targets inline per column and in dedicated relationships summary
+  - Added footer note when tables are truncated due to `max_tables` limit
+  - Better **readability** for AI context consumption and human review
+
 ## [1.28.0] - 2025-12-21
 
 ### Changed

package/DOCUMENTATIONS.md

@@ -1,6 +1,6 @@
 # MySQL MCP Server - Detailed Documentation
 
-**Last Updated:** 2025-12-21 17:00:00
+**Last Updated:** 2025-12-22 15:30:00
 
 This file contains detailed documentation for all features of the MySQL MCP Server. For quick start and basic information, see [README.md](README.md).
 
@@ -439,11 +439,19 @@ This section provides a comprehensive reference of all 145 available tools organ
 
 | Tool | Description | Requires |
 |------|-------------|----------|
-| `get_database_summary` | High-level overview (tables, columns, rows) for AI context | `list` |
+| `get_database_summary` | Enhanced database overview with overview section, per-table breakdown (PKs, columns with nullable info, FK references), optional relationships summary, and configurable table limits | `list` |
 | `get_schema_erd` | Generate Mermaid.js ER diagram for visualization | `list` |
 | `get_schema_rag_context` | Condensed schema snapshot (tables, PK/FK, row estimates) for RAG prompts | `list` |
 | `get_column_statistics` | Profile data (min, max, nulls, distinct) for analysis | `read` |
 
+#### Database Summary Enhancement
+- **Better readability**: Columns displayed one per line with type, nullable status, and key indicators (PK, UNI, FK with target)
+- **Overview section**: Shows total tables, tables displayed, and total estimated rows
+- **Configurable limits**: Use `max_tables` parameter (max 500) to limit output for large databases
+- **Relationship tracking**: Automatically includes foreign key relationships (set `include_relationships: false` to disable)
+- **Formatted output**: Uses markdown headings for clear hierarchy, number formatting with thousands separators
+- **Foreign key details**: Shows FK targets inline per column and in dedicated relationships section
+
 #### Schema-Aware RAG Context Pack
 - Purpose-built for embeddings: returns a `context_text` block plus structured `tables` and `relationships` so agents can self-orient without pulling a full ERD.
 - Tunable size: `max_tables` (default 50, max 200) and `max_columns` (default 12) to control output length; set `include_relationships` to `false` to omit FK lines.

package/README.md

@@ -4,7 +4,7 @@
 
 **A production-ready Model Context Protocol (MCP) server for MySQL database integration with AI agents**
 
-**Last Updated:** 2025-12-21 17:00:00
+**Last Updated:** 2025-12-22 15:30:00
 
 [![npm version](https://img.shields.io/npm/v/@berthojoris/mcp-mysql-server)](https://www.npmjs.com/package/@berthojoris/mysql-mcp)
 [![npm downloads](https://img.shields.io/npm/dm/@berthojoris/mysql-mcp)](https://www.npmjs.com/package/@berthojoris/mysql-mcp)

package/dist/index.d.ts

@@ -61,6 +61,8 @@ export declare class MySQLMCP {
     }>;
     getDatabaseSummary(params: {
         database?: string;
+        max_tables?: number;
+        include_relationships?: boolean;
     }): Promise<{
         status: string;
         data?: string;

package/dist/mcp-server.js

@@ -37,7 +37,7 @@ const TOOLS = [
     },
     {
         name: "get_database_summary",
-        description: "📊 Returns a high-level overview of the database including all tables, their columns, data types, and row counts. RECOMMENDED: Use this first when exploring a new database to understand its structure quickly. Optimized for AI context with concise formatting.",
+        description: "📊 Returns a high-level overview of the database including all tables, their columns, data types, row counts, and relationships. RECOMMENDED: Use this first when exploring a new database to understand its structure quickly. Features: database overview, per-table breakdown with primary keys, columns with nullable info and foreign key references, optional relationship summary, and configurable table limits.",
         inputSchema: {
             type: "object",
             properties: {
@@ -45,6 +45,14 @@ const TOOLS = [
                     type: "string",
                     description: "Optional: specific database name",
                 },
+                max_tables: {
+                    type: "number",
+                    description: "Optional: maximum number of tables to include (default: all tables, max 500)",
+                },
+                include_relationships: {
+                    type: "boolean",
+                    description: "Optional: include foreign key relationships section (default: true)",
+                },
             },
         },
     },

package/dist/security/securityLayer.js

@@ -201,9 +201,9 @@ class SecurityLayer {
         }
         // Check for comment-like sequences that could be used for injection
         const suspiciousPatterns = [
-            /\/*/, // Potential comment start
-            /\*\//, // Potential comment end
-            /--/, // Potential comment
+            /\/\*/, // Potential comment start (literal /*)
+            /\*\//, // Potential comment end (literal */)
+            /--\s/, // Potential comment (-- followed by space, not -- in dates)
             /#/, // Potential comment
         ];
         for (const pattern of suspiciousPatterns) {

package/dist/tools/databaseTools.d.ts

@@ -33,10 +33,12 @@ export declare class DatabaseTools {
     }>;
     /**
      * Get a high-level summary of the database (tables, columns, row counts)
-     * Optimized for AI context window
+     * Optimized for AI context window with better formatting and optional limits
      */
     getDatabaseSummary(params: {
         database?: string;
+        max_tables?: number;
+        include_relationships?: boolean;
     }): Promise<{
         status: string;
         data?: string;

package/dist/tools/databaseTools.js

@@ -141,7 +141,7 @@ class DatabaseTools {
     }
     /**
      * Get a high-level summary of the database (tables, columns, row counts)
-     * Optimized for AI context window
+     * Optimized for AI context window with better formatting and optional limits
      */
     async getDatabaseSummary(params) {
         try {
@@ -159,37 +159,112 @@ class DatabaseTools {
                     error: "No database specified and none connected.",
                 };
             }
-            // Get tables and row counts
+            const maxTables = params.max_tables ? Math.min(Math.max(params.max_tables, 1), 500) : undefined;
+            const includeRelationships = params.include_relationships ?? true;
+            // Get total table count first
+            const totalCountQuery = `
+        SELECT COUNT(*) as total
+        FROM INFORMATION_SCHEMA.TABLES 
+        WHERE TABLE_SCHEMA = ?
+      `;
+            const totalCountResult = await this.db.query(totalCountQuery, [database]);
+            const totalTables = totalCountResult[0]?.total || 0;
+            // Get tables and row counts with optional limit
             const tablesQuery = `
         SELECT TABLE_NAME, TABLE_ROWS
         FROM INFORMATION_SCHEMA.TABLES 
         WHERE TABLE_SCHEMA = ?
+        ORDER BY TABLE_NAME
+        ${maxTables ? `LIMIT ${maxTables}` : ''}
       `;
             const tables = await this.db.query(tablesQuery, [database]);
-            // Get columns for all tables
+            if (tables.length === 0) {
+                return {
+                    status: "success",
+                    data: `# Database Summary: ${database}\n\nNo tables found in this database.`
+                };
+            }
+            // Get columns for displayed tables
+            const tableNames = tables.map(t => t.TABLE_NAME);
+            const placeholders = tableNames.map(() => '?').join(',');
             const columnsQuery = `
-        SELECT TABLE_NAME, COLUMN_NAME, DATA_TYPE, COLUMN_KEY
+        SELECT TABLE_NAME, COLUMN_NAME, DATA_TYPE, COLUMN_KEY, IS_NULLABLE
         FROM INFORMATION_SCHEMA.COLUMNS 
-        WHERE TABLE_SCHEMA = ?
+        WHERE TABLE_SCHEMA = ? AND TABLE_NAME IN (${placeholders})
         ORDER BY TABLE_NAME, ORDINAL_POSITION
       `;
-            const columns = await this.db.query(columnsQuery, [database]);
-            // Build text summary
+            const columns = await this.db.query(columnsQuery, [database, ...tableNames]);
+            // Get foreign key relationships if requested
+            let foreignKeys = [];
+            if (includeRelationships) {
+                const fkQuery = `
+          SELECT 
+            TABLE_NAME,
+            COLUMN_NAME,
+            REFERENCED_TABLE_NAME,
+            REFERENCED_COLUMN_NAME
+          FROM INFORMATION_SCHEMA.KEY_COLUMN_USAGE
+          WHERE TABLE_SCHEMA = ? 
+            AND TABLE_NAME IN (${placeholders})
+            AND REFERENCED_TABLE_NAME IS NOT NULL
+        `;
+                foreignKeys = await this.db.query(fkQuery, [database, ...tableNames]);
+            }
+            // Build enhanced summary
             let summary = `# Database Summary: ${database}\n\n`;
+            // Overview section
+            summary += `## Overview\n`;
+            summary += `- **Total Tables**: ${totalTables}\n`;
+            summary += `- **Tables Shown**: ${tables.length}${maxTables && totalTables > maxTables ? ` (limited to ${maxTables})` : ''}\n`;
+            const totalRows = tables.reduce((sum, t) => sum + (parseInt(t.TABLE_ROWS) || 0), 0);
+            summary += `- **Total Estimated Rows**: ~${totalRows.toLocaleString()}\n\n`;
+            // Tables section
+            summary += `## Tables\n\n`;
             for (const table of tables) {
-                summary += `## Table: ${table.TABLE_NAME} (~${table.TABLE_ROWS || 0} rows)\n`;
+                const rowCount = parseInt(table.TABLE_ROWS) || 0;
+                summary += `### ${table.TABLE_NAME}\n`;
+                summary += `**Rows**: ~${rowCount.toLocaleString()}\n\n`;
                 const tableColumns = columns.filter(c => c.TABLE_NAME === table.TABLE_NAME);
-                const columnDefs = tableColumns.map(c => {
-                    let def = `${c.COLUMN_NAME} (${c.DATA_TYPE})`;
-                    if (c.COLUMN_KEY === 'PRI')
-                        def += " [PK]";
-                    if (c.COLUMN_KEY === 'MUL')
-                        def += " [FK/Index]";
-                    if (c.COLUMN_KEY === 'UNI')
-                        def += " [Unique]";
-                    return def;
-                });
-                summary += `Columns: ${columnDefs.join(", ")}\n\n`;
+                const tableFKs = foreignKeys.filter(fk => fk.TABLE_NAME === table.TABLE_NAME);
+                // Primary keys
+                const primaryKeys = tableColumns.filter(c => c.COLUMN_KEY === 'PRI');
+                if (primaryKeys.length > 0) {
+                    summary += `**Primary Key(s)**: ${primaryKeys.map(c => c.COLUMN_NAME).join(', ')}\n\n`;
+                }
+                // Columns
+                summary += `**Columns** (${tableColumns.length}):\n`;
+                for (const col of tableColumns) {
+                    const nullable = col.IS_NULLABLE === 'YES' ? 'nullable' : 'not null';
+                    let keys = [];
+                    if (col.COLUMN_KEY === 'PRI')
+                        keys.push('PK');
+                    else if (col.COLUMN_KEY === 'UNI')
+                        keys.push('UNI');
+                    // Check if this column is a foreign key
+                    const fk = tableFKs.find(f => f.COLUMN_NAME === col.COLUMN_NAME);
+                    if (fk) {
+                        keys.push(`FK → ${fk.REFERENCED_TABLE_NAME}.${fk.REFERENCED_COLUMN_NAME}`);
+                    }
+                    else if (col.COLUMN_KEY === 'MUL') {
+                        keys.push('Index');
+                    }
+                    const keyInfo = keys.length > 0 ? ` [${keys.join(', ')}]` : '';
+                    summary += `  - ${col.COLUMN_NAME}: ${col.DATA_TYPE} (${nullable})${keyInfo}\n`;
+                }
+                summary += `\n`;
+            }
+            // Relationships summary if included and exists
+            if (includeRelationships && foreignKeys.length > 0) {
+                summary += `## Foreign Key Relationships (${foreignKeys.length})\n\n`;
+                for (const fk of foreignKeys) {
+                    summary += `- ${fk.TABLE_NAME}.${fk.COLUMN_NAME} → ${fk.REFERENCED_TABLE_NAME}.${fk.REFERENCED_COLUMN_NAME}\n`;
+                }
+                summary += `\n`;
+            }
+            // Footer note if tables were limited
+            if (maxTables && totalTables > maxTables) {
+                summary += `\n---\n`;
+                summary += `*Note: ${totalTables - maxTables} table(s) not shown. Increase \`max_tables\` parameter to see more.*\n`;
             }
             return {
                 status: "success",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@berthojoris/mcp-mysql-server",
-  "version": "1.28.0",
+  "version": "1.30.0",
   "description": "Model Context Protocol server for MySQL database integration with dynamic per-project permissions, backup/restore, data import/export, and data migration capabilities",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",