mcp-database-inspector 2.0.1

package/dist/tools/analyze-query.d.ts

@@ -0,0 +1,27 @@
+import { z } from 'zod';
+import { DatabaseManager } from '../database/manager.js';
+export declare const AnalyzeQueryArgsSchema: z.ZodObject<{
+    database: z.ZodString;
+    query: z.ZodString;
+}, z.core.$strip>;
+export interface AnalyzeQueryTool {
+    name: 'analyze_query';
+    description: 'Analyze a SQL query performance and provide recommendations';
+    inputSchema: {
+        type: 'object';
+        properties: {
+            database: {
+                type: 'string';
+                description: 'Name of the database to run the analysis against';
+            };
+            query: {
+                type: 'string';
+                description: 'The SQL query to analyze';
+            };
+        };
+        required: ['database', 'query'];
+    };
+}
+export declare const analyzeQueryToolDefinition: AnalyzeQueryTool;
+export declare function handleAnalyzeQuery(args: unknown, dbManager: DatabaseManager): Promise<any>;
+//# sourceMappingURL=analyze-query.d.ts.map

package/dist/tools/analyze-query.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"analyze-query.d.ts","sourceRoot":"","sources":["../../src/tools/analyze-query.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAMzD,eAAO,MAAM,sBAAsB;;;iBAGjC,CAAC;AAEH,MAAM,WAAW,gBAAgB;IAC/B,IAAI,EAAE,eAAe,CAAC;IACtB,WAAW,EAAE,6DAA6D,CAAC;IAC3E,WAAW,EAAE;QACX,IAAI,EAAE,QAAQ,CAAC;QACf,UAAU,EAAE;YACV,QAAQ,EAAE;gBACR,IAAI,EAAE,QAAQ,CAAC;gBACf,WAAW,EAAE,kDAAkD,CAAC;aACjE,CAAC;YACF,KAAK,EAAE;gBACL,IAAI,EAAE,QAAQ,CAAC;gBACf,WAAW,EAAE,0BAA0B,CAAC;aACzC,CAAC;SACH,CAAC;QACF,QAAQ,EAAE,CAAC,UAAU,EAAE,OAAO,CAAC,CAAC;KACjC,CAAC;CACH;AAED,eAAO,MAAM,0BAA0B,EAAE,gBAiBxC,CAAC;AAEF,wBAAsB,kBAAkB,CACtC,IAAI,EAAE,OAAO,EACb,SAAS,EAAE,eAAe,GACzB,OAAO,CAAC,GAAG,CAAC,CA0Dd"}

package/dist/tools/analyze-query.js

@@ -0,0 +1,71 @@
+import { z } from 'zod';
+import { InputValidator } from '../validators/input-validator.js';
+import { Logger } from '../utils/logger.js';
+import { ToolError } from '../utils/errors.js';
+// Tool schema
+export const AnalyzeQueryArgsSchema = z.object({
+    database: z.string().min(1, 'Database name is required'),
+    query: z.string().min(1, 'SQL query is required')
+});
+export const analyzeQueryToolDefinition = {
+    name: 'analyze_query',
+    description: 'Analyze a SQL query performance and provide recommendations',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            database: {
+                type: 'string',
+                description: 'Name of the database to run the analysis against'
+            },
+            query: {
+                type: 'string',
+                description: 'The SQL query to analyze'
+            }
+        },
+        required: ['database', 'query']
+    }
+};
+export async function handleAnalyzeQuery(args, dbManager) {
+    try {
+        Logger.info('Executing analyze_query tool');
+        // Validate arguments
+        const validationResult = AnalyzeQueryArgsSchema.safeParse(args);
+        if (!validationResult.success) {
+            Logger.warn('Invalid arguments for analyze_query', validationResult.error);
+            throw new ToolError(`Invalid arguments: ${validationResult.error.issues.map(e => `${e.path.join('.')}: ${e.message}`).join(', ')}`, 'analyze_query');
+        }
+        const { database, query } = validationResult.data;
+        // Sanitize database name
+        const sanitizedDatabase = InputValidator.sanitizeString(database);
+        Logger.info(`Analyzing query for database: ${sanitizedDatabase}`);
+        const analysis = await dbManager.analyzeQuery(sanitizedDatabase, query);
+        const response = {
+            database: sanitizedDatabase,
+            query: analysis.query,
+            type: analysis.type,
+            summary: {
+                cost: analysis.summary.cost,
+                operations: analysis.summary.operations,
+                potentialIssues: analysis.summary.potentialIssues,
+                recommendation: analysis.summary.potentialIssues.length > 0
+                    ? `Found ${analysis.summary.potentialIssues.length} potential performance issues. Consider adding indexes or refactoring the query.`
+                    : 'No major performance issues detected in the execution plan.'
+            },
+            executionPlan: analysis.plan
+        };
+        return {
+            content: [{
+                    type: 'text',
+                    text: JSON.stringify(response, null, 2)
+                }]
+        };
+    }
+    catch (error) {
+        Logger.error('Error in analyze_query tool', error);
+        if (error instanceof ToolError) {
+            throw error;
+        }
+        throw new ToolError(`Failed to analyze query: ${error instanceof Error ? error.message : 'Unknown error'}`, 'analyze_query', error instanceof Error ? error : undefined);
+    }
+}
+//# sourceMappingURL=analyze-query.js.map

package/dist/tools/analyze-query.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"analyze-query.js","sourceRoot":"","sources":["../../src/tools/analyze-query.ts"],"names":[],"mappings":"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"}

package/dist/tools/execute-query.d.ts

@@ -0,0 +1,33 @@
+import { DatabaseManager } from '../database/manager.js';
+export interface ExecuteQueryTool {
+    name: 'execute_query';
+    description: 'Execute a safe read-only SQL query (SELECT, SHOW, DESCRIBE, EXPLAIN). Automatic row limits are applied for security.';
+    inputSchema: {
+        type: 'object';
+        properties: {
+            database: {
+                type: 'string';
+                description: 'Database name';
+            };
+            query: {
+                type: 'string';
+                description: 'SQL query to execute';
+            };
+            params?: {
+                type: 'array';
+                items: {
+                    type: 'any';
+                };
+                description: 'Optional parameters for the query';
+            };
+            limit?: {
+                type: 'number';
+                description: 'Optional limit for number of rows (default 1000, max 1000)';
+            };
+        };
+        required: ['database', 'query'];
+    };
+}
+export declare const executeQueryToolDefinition: ExecuteQueryTool;
+export declare function handleExecuteQuery(args: unknown, dbManager: DatabaseManager): Promise<any>;
+//# sourceMappingURL=execute-query.d.ts.map

package/dist/tools/execute-query.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"execute-query.d.ts","sourceRoot":"","sources":["../../src/tools/execute-query.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAazD,MAAM,WAAW,gBAAgB;IAC/B,IAAI,EAAE,eAAe,CAAC;IACtB,WAAW,EAAE,sHAAsH,CAAC;IACpI,WAAW,EAAE;QACX,IAAI,EAAE,QAAQ,CAAC;QACf,UAAU,EAAE;YACV,QAAQ,EAAE;gBAAE,IAAI,EAAE,QAAQ,CAAC;gBAAC,WAAW,EAAE,eAAe,CAAA;aAAE,CAAC;YAC3D,KAAK,EAAE;gBAAE,IAAI,EAAE,QAAQ,CAAC;gBAAC,WAAW,EAAE,sBAAsB,CAAA;aAAE,CAAC;YAC/D,MAAM,CAAC,EAAE;gBAAE,IAAI,EAAE,OAAO,CAAC;gBAAC,KAAK,EAAE;oBAAE,IAAI,EAAE,KAAK,CAAA;iBAAE,CAAC;gBAAC,WAAW,EAAE,mCAAmC,CAAA;aAAE,CAAC;YACrG,KAAK,CAAC,EAAE;gBAAE,IAAI,EAAE,QAAQ,CAAC;gBAAC,WAAW,EAAE,4DAA4D,CAAA;aAAE,CAAC;SACvG,CAAC;QACF,QAAQ,EAAE,CAAC,UAAU,EAAE,OAAO,CAAC,CAAC;KACjC,CAAC;CACH;AAED,eAAO,MAAM,0BAA0B,EAAE,gBAaxC,CAAC;AAEF,wBAAsB,kBAAkB,CACtC,IAAI,EAAE,OAAO,EACb,SAAS,EAAE,eAAe,GACzB,OAAO,CAAC,GAAG,CAAC,CA2Cd"}

package/dist/tools/execute-query.js

@@ -0,0 +1,57 @@
+import { z } from 'zod';
+import { InputValidator } from '../validators/input-validator.js';
+import { Logger } from '../utils/logger.js';
+import { ToolError } from '../utils/errors.js';
+// Zod schema for arguments
+const ExecuteQueryArgsSchema = z.object({
+    database: z.string().min(1, 'Database name is required'),
+    query: z.string().min(1, 'SQL query is required'),
+    params: z.array(z.any()).optional(),
+    limit: z.number().int().min(1).max(1000).optional()
+});
+export const executeQueryToolDefinition = {
+    name: 'execute_query',
+    description: 'Execute a safe read-only SQL query (SELECT, SHOW, DESCRIBE, EXPLAIN). Automatic row limits are applied for security.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            database: { type: 'string', description: 'Database name' },
+            query: { type: 'string', description: 'SQL query to execute' },
+            params: { type: 'array', items: { type: 'any' }, description: 'Optional parameters for the query' },
+            limit: { type: 'number', description: 'Optional limit for number of rows (default 1000, max 1000)' }
+        },
+        required: ['database', 'query']
+    }
+};
+export async function handleExecuteQuery(args, dbManager) {
+    try {
+        Logger.info('Executing execute_query tool');
+        const validationResult = ExecuteQueryArgsSchema.safeParse(args);
+        if (!validationResult.success) {
+            Logger.warn('Invalid arguments for execute_query', validationResult.error);
+            throw new ToolError(`Invalid arguments: ${validationResult.error.issues.map(e => `${e.path.join('.')}: ${e.message}`).join(', ')}`, 'execute_query');
+        }
+        const { database, query, params, limit } = validationResult.data;
+        // Sanitize and validate database name
+        const sanitizedDatabase = InputValidator.sanitizeString(database);
+        const dbNameValidation = InputValidator.validateDatabaseName(sanitizedDatabase);
+        if (!dbNameValidation.isValid) {
+            throw new ToolError(`Invalid database name: ${dbNameValidation.error}`, 'execute_query');
+        }
+        Logger.info(`Executing query on database ${sanitizedDatabase}`);
+        const result = await dbManager.executeQuery(sanitizedDatabase, query, params);
+        return {
+            content: [{
+                    type: 'text',
+                    text: JSON.stringify(result.rows, null, 2)
+                }]
+        };
+    }
+    catch (error) {
+        Logger.error('Error in execute_query tool', error);
+        if (error instanceof ToolError)
+            throw error;
+        throw new ToolError(`Failed to execute query: ${error instanceof Error ? error.message : 'Unknown error'}`, 'execute_query', error instanceof Error ? error : undefined);
+    }
+}
+//# sourceMappingURL=execute-query.js.map

package/dist/tools/execute-query.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"execute-query.js","sourceRoot":"","sources":["../../src/tools/execute-query.ts"],"names":[],"mappings":"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"}

package/dist/tools/get-foreign-keys.d.ts

@@ -0,0 +1,38 @@
+import { DatabaseManager } from '../database/manager.js';
+/**
+ * Tool: get_foreign_keys
+ * Get foreign key relationships for one or more tables, or the entire database.
+ *
+ * Supports both single-table and multi-table inspection:
+ * - Provide either `table` (string) for a single table, or `tables` (string[]) for multiple tables.
+ * - If `tables` is provided, returns a mapping of table names to their foreign key analysis.
+ * - Do not provide both `table` and `tables` at the same time.
+ */
+export interface GetForeignKeysTool {
+    name: 'get_foreign_keys';
+    description: 'Get foreign key relationships for one or more tables, or the entire database. Supports multi-table inspection via the tables: string[] parameter.';
+    inputSchema: {
+        type: 'object';
+        properties: {
+            database: {
+                type: 'string';
+                description: 'Name of the database to analyze';
+            };
+            table: {
+                type: 'string';
+                description: 'Specific table name to get foreign keys for (single-table mode)';
+            };
+            tables: {
+                type: 'array';
+                items: {
+                    type: 'string';
+                };
+                description: 'Array of table names to get foreign keys for (multi-table mode)';
+            };
+        };
+        required: ['database'];
+    };
+}
+export declare const getForeignKeysToolDefinition: GetForeignKeysTool;
+export declare function handleGetForeignKeys(args: unknown, dbManager: DatabaseManager): Promise<any>;
+//# sourceMappingURL=get-foreign-keys.d.ts.map

package/dist/tools/get-foreign-keys.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-foreign-keys.d.ts","sourceRoot":"","sources":["../../src/tools/get-foreign-keys.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AA0BzD;;;;;;;;GAQG;AACH,MAAM,WAAW,kBAAkB;IACjC,IAAI,EAAE,kBAAkB,CAAC;IACzB,WAAW,EAAE,mJAAmJ,CAAC;IACjK,WAAW,EAAE;QACX,IAAI,EAAE,QAAQ,CAAC;QACf,UAAU,EAAE;YACV,QAAQ,EAAE;gBACR,IAAI,EAAE,QAAQ,CAAC;gBACf,WAAW,EAAE,iCAAiC,CAAC;aAChD,CAAC;YACF,KAAK,EAAE;gBACL,IAAI,EAAE,QAAQ,CAAC;gBACf,WAAW,EAAE,iEAAiE,CAAC;aAChF,CAAC;YACF,MAAM,EAAE;gBACN,IAAI,EAAE,OAAO,CAAC;gBACd,KAAK,EAAE;oBAAE,IAAI,EAAE,QAAQ,CAAA;iBAAE,CAAC;gBAC1B,WAAW,EAAE,iEAAiE,CAAC;aAChF,CAAC;SACH,CAAC;QACF,QAAQ,EAAE,CAAC,UAAU,CAAC,CAAC;KACxB,CAAC;CACH;AAED,eAAO,MAAM,4BAA4B,EAAE,kBAsB1C,CAAC;AAEF,wBAAsB,oBAAoB,CACxC,IAAI,EAAE,OAAO,EACb,SAAS,EAAE,eAAe,GACzB,OAAO,CAAC,GAAG,CAAC,CAqOd"}

package/dist/tools/get-foreign-keys.js

@@ -0,0 +1,391 @@
+import { z } from 'zod';
+import { InputValidator } from '../validators/input-validator.js';
+import { Logger } from '../utils/logger.js';
+import { ToolError } from '../utils/errors.js';
+// Tool schema
+const GetForeignKeysArgsSchema = z.object({
+    database: z.string().min(1, 'Database name is required'),
+    table: z.string().optional(),
+    tables: z.array(z.string().min(1)).optional()
+}).superRefine((data, ctx) => {
+    const hasTable = typeof data.table === 'string' && data.table.length > 0;
+    const hasTables = Array.isArray(data.tables) && data.tables.length > 0;
+    if (hasTable && hasTables) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: "Provide either 'table' or 'tables', not both"
+        });
+    }
+    else if (!hasTable && !hasTables) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: "Either 'table' or non-empty 'tables' must be provided"
+        });
+    }
+});
+export const getForeignKeysToolDefinition = {
+    name: 'get_foreign_keys',
+    description: 'Get foreign key relationships for one or more tables, or the entire database. Supports multi-table inspection via the tables: string[] parameter.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            database: {
+                type: 'string',
+                description: 'Name of the database to analyze'
+            },
+            table: {
+                type: 'string',
+                description: 'Specific table name to get foreign keys for (single-table mode)'
+            },
+            tables: {
+                type: 'array',
+                items: { type: 'string' },
+                description: 'Array of table names to get foreign keys for (multi-table mode)'
+            }
+        },
+        required: ['database']
+    }
+};
+export async function handleGetForeignKeys(args, dbManager) {
+    try {
+        Logger.info('Executing get_foreign_keys tool');
+        // Validate arguments
+        const validationResult = GetForeignKeysArgsSchema.safeParse(args);
+        if (!validationResult.success) {
+            Logger.warn('Invalid arguments for get_foreign_keys', validationResult.error);
+            throw new ToolError(`Invalid arguments: ${validationResult.error.issues.map(e => `${e.path.join('.')}: ${e.message}`).join(', ')}`, 'get_foreign_keys');
+        }
+        const { database, table, tables } = validationResult.data;
+        // Sanitize inputs
+        const sanitizedDatabase = InputValidator.sanitizeString(database);
+        const sanitizedTable = table ? InputValidator.sanitizeString(table) : undefined;
+        const sanitizedTables = tables ? tables.map(InputValidator.sanitizeString) : undefined;
+        // Validate database name format
+        const dbNameValidation = InputValidator.validateDatabaseName(sanitizedDatabase);
+        if (!dbNameValidation.isValid) {
+            throw new ToolError(`Invalid database name: ${dbNameValidation.error}`, 'get_foreign_keys');
+        }
+        // Multi-table mode
+        if (sanitizedTables && sanitizedTables.length > 0) {
+            Logger.info(`Multi-table mode: Getting foreign keys for tables: ${sanitizedTables.join(', ')} in database: ${sanitizedDatabase}`);
+            const results = {};
+            const errors = {};
+            for (const tbl of sanitizedTables) {
+                try {
+                    const tableNameValidation = InputValidator.validateTableName(tbl);
+                    if (!tableNameValidation.isValid) {
+                        throw new ToolError(`Invalid table name: ${tableNameValidation.error}`, 'get_foreign_keys');
+                    }
+                    Logger.info(`Getting foreign keys for table: ${tbl} in database: ${sanitizedDatabase}`);
+                    Logger.time(`get_foreign_keys_execution_${tbl}`);
+                    const foreignKeys = await dbManager.getForeignKeys(sanitizedDatabase, tbl);
+                    Logger.timeEnd(`get_foreign_keys_execution_${tbl}`);
+                    Logger.info(`Found ${foreignKeys.length} foreign key(s) in table: ${tbl}`);
+                    const analysis = analyzeForeignKeyRelationships(foreignKeys);
+                    const foreignKeysByTable = groupForeignKeysByTable(foreignKeys);
+                    results[tbl] = {
+                        database: sanitizedDatabase,
+                        table: tbl,
+                        scope: 'table',
+                        foreignKeys: foreignKeys.map(fk => ({
+                            constraintName: fk.constraintName,
+                            sourceTable: fk.tableName,
+                            sourceColumn: fk.columnName,
+                            targetTable: fk.referencedTableName,
+                            targetColumn: fk.referencedColumnName,
+                            updateRule: fk.updateRule,
+                            deleteRule: fk.deleteRule,
+                            relationshipType: determineRelationshipType(fk.updateRule || 'NO ACTION', fk.deleteRule || 'NO ACTION')
+                        })),
+                        relationships: analysis.relationships,
+                        statistics: {
+                            totalForeignKeys: foreignKeys.length,
+                            uniqueConstraints: [...new Set(foreignKeys.map(fk => fk.constraintName))].length,
+                            affectedTables: [...new Set(foreignKeys.map(fk => fk.tableName))].length,
+                            referencedTables: [...new Set(foreignKeys.map(fk => fk.referencedTableName))].length,
+                            cascadeDeleteCount: foreignKeys.filter(fk => fk.deleteRule === 'CASCADE').length,
+                            cascadeUpdateCount: foreignKeys.filter(fk => fk.updateRule === 'CASCADE').length,
+                            restrictDeleteCount: foreignKeys.filter(fk => fk.deleteRule === 'RESTRICT').length,
+                            restrictUpdateCount: foreignKeys.filter(fk => fk.updateRule === 'RESTRICT').length
+                        },
+                        foreignKeysByTable,
+                        analysis: {
+                            ...analysis,
+                            integrityRules: analyzeIntegrityRules(foreignKeys),
+                            potentialIssues: identifyPotentialIssues(foreignKeys)
+                        },
+                        summary: {
+                            hasRelationships: foreignKeys.length > 0,
+                            message: foreignKeys.length === 0
+                                ? `No foreign key relationships found in table '${tbl}' of database '${sanitizedDatabase}'`
+                                : `Found ${foreignKeys.length} foreign key relationship(s) in table '${tbl}' involving ${analysis.relationships.length} table connection(s)`
+                        }
+                    };
+                    Logger.debug('get_foreign_keys completed for table', {
+                        database: sanitizedDatabase,
+                        table: tbl,
+                        foreignKeyCount: foreignKeys.length,
+                        relationshipCount: analysis.relationships.length
+                    });
+                }
+                catch (err) {
+                    Logger.error(`Error processing table '${tbl}' in get_foreign_keys`, err);
+                    errors[tbl] = err instanceof Error ? err.message : String(err);
+                }
+            }
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({ database: sanitizedDatabase, results, errors }, null, 2)
+                    }]
+            };
+        }
+        // Single-table or all-tables mode (original behavior)
+        // Validate table name format if provided
+        if (sanitizedTable) {
+            const tableNameValidation = InputValidator.validateTableName(sanitizedTable);
+            if (!tableNameValidation.isValid) {
+                throw new ToolError(`Invalid table name: ${tableNameValidation.error}`, 'get_foreign_keys');
+            }
+        }
+        const scope = sanitizedTable ? `table: ${sanitizedTable}` : 'entire database';
+        Logger.info(`Getting foreign keys for ${scope} in database: ${sanitizedDatabase}`);
+        Logger.time('get_foreign_keys_execution');
+        // Get foreign keys
+        const foreignKeys = await dbManager.getForeignKeys(sanitizedDatabase, sanitizedTable);
+        Logger.timeEnd('get_foreign_keys_execution');
+        Logger.info(`Found ${foreignKeys.length} foreign key(s) in ${scope}`);
+        // Analyze relationships
+        const analysis = analyzeForeignKeyRelationships(foreignKeys);
+        // Group foreign keys by table
+        const foreignKeysByTable = groupForeignKeysByTable(foreignKeys);
+        // Create response
+        const response = {
+            database: sanitizedDatabase,
+            table: sanitizedTable || null,
+            scope: sanitizedTable ? 'table' : 'database',
+            foreignKeys: foreignKeys.map(fk => ({
+                constraintName: fk.constraintName,
+                sourceTable: fk.tableName,
+                sourceColumn: fk.columnName,
+                targetTable: fk.referencedTableName,
+                targetColumn: fk.referencedColumnName,
+                updateRule: fk.updateRule,
+                deleteRule: fk.deleteRule,
+                relationshipType: determineRelationshipType(fk.updateRule || 'NO ACTION', fk.deleteRule || 'NO ACTION')
+            })),
+            relationships: analysis.relationships,
+            statistics: {
+                totalForeignKeys: foreignKeys.length,
+                uniqueConstraints: [...new Set(foreignKeys.map(fk => fk.constraintName))].length,
+                affectedTables: [...new Set(foreignKeys.map(fk => fk.tableName))].length,
+                referencedTables: [...new Set(foreignKeys.map(fk => fk.referencedTableName))].length,
+                cascadeDeleteCount: foreignKeys.filter(fk => fk.deleteRule === 'CASCADE').length,
+                cascadeUpdateCount: foreignKeys.filter(fk => fk.updateRule === 'CASCADE').length,
+                restrictDeleteCount: foreignKeys.filter(fk => fk.deleteRule === 'RESTRICT').length,
+                restrictUpdateCount: foreignKeys.filter(fk => fk.updateRule === 'RESTRICT').length
+            },
+            foreignKeysByTable,
+            analysis: {
+                ...analysis,
+                integrityRules: analyzeIntegrityRules(foreignKeys),
+                potentialIssues: identifyPotentialIssues(foreignKeys)
+            },
+            summary: {
+                hasRelationships: foreignKeys.length > 0,
+                message: foreignKeys.length === 0
+                    ? `No foreign key relationships found in ${scope} of database '${sanitizedDatabase}'`
+                    : `Found ${foreignKeys.length} foreign key relationship(s) in ${scope} involving ${analysis.relationships.length} table connection(s)`
+            }
+        };
+        Logger.debug('get_foreign_keys completed successfully', {
+            database: sanitizedDatabase,
+            table: sanitizedTable,
+            foreignKeyCount: foreignKeys.length,
+            relationshipCount: analysis.relationships.length
+        });
+        return {
+            content: [{
+                    type: 'text',
+                    text: JSON.stringify(response, null, 2)
+                }]
+        };
+    }
+    catch (error) {
+        // Add table context to error logs
+        let tableContext;
+        let argTables;
+        let argTable;
+        if (args && typeof args === 'object') {
+            // @ts-ignore
+            argTables = Array.isArray(args.tables) ? args.tables : undefined;
+            // @ts-ignore
+            argTable = typeof args.table === 'string' ? args.table : undefined;
+        }
+        if (Array.isArray(argTables) && argTables.length > 0) {
+            tableContext = `tables: [${argTables.join(', ')}]`;
+        }
+        else if (typeof argTable === 'string' && argTable.length > 0) {
+            tableContext = `table: ${argTable}`;
+        }
+        else {
+            tableContext = 'no table(s) specified';
+        }
+        Logger.error(`Error in get_foreign_keys tool (${tableContext})`, error);
+        if (error instanceof ToolError) {
+            throw error;
+        }
+        throw new ToolError(`Failed to get foreign keys (${tableContext}): ${error instanceof Error ? error.message : 'Unknown error'}`, 'get_foreign_keys', error instanceof Error ? error : undefined);
+    }
+}
+// Helper functions
+function groupForeignKeysByTable(foreignKeys) {
+    const groups = {};
+    foreignKeys.forEach(fk => {
+        if (!groups[fk.tableName]) {
+            groups[fk.tableName] = [];
+        }
+        groups[fk.tableName].push({
+            constraintName: fk.constraintName,
+            column: fk.columnName,
+            referencedTable: fk.referencedTableName,
+            referencedColumn: fk.referencedColumnName,
+            updateRule: fk.updateRule,
+            deleteRule: fk.deleteRule
+        });
+    });
+    return groups;
+}
+function analyzeForeignKeyRelationships(foreignKeys) {
+    const relationships = [];
+    const tableConnections = {};
+    // Group by constraint to handle composite foreign keys
+    const constraintGroups = {};
+    foreignKeys.forEach(fk => {
+        if (!constraintGroups[fk.constraintName]) {
+            constraintGroups[fk.constraintName] = [];
+        }
+        constraintGroups[fk.constraintName].push(fk);
+    });
+    // Analyze each constraint
+    Object.keys(constraintGroups).forEach(constraintName => {
+        const fks = constraintGroups[constraintName];
+        const firstFK = fks[0];
+        relationships.push({
+            constraintName,
+            fromTable: firstFK.tableName,
+            toTable: firstFK.referencedTableName,
+            columns: fks.map(fk => ({
+                from: fk.columnName,
+                to: fk.referencedColumnName
+            })),
+            isComposite: fks.length > 1,
+            updateRule: firstFK.updateRule,
+            deleteRule: firstFK.deleteRule,
+            relationshipStrength: determineRelationshipStrength(firstFK.updateRule, firstFK.deleteRule)
+        });
+        // Track table connections
+        if (!tableConnections[firstFK.tableName]) {
+            tableConnections[firstFK.tableName] = new Set();
+        }
+        tableConnections[firstFK.tableName].add(firstFK.referencedTableName);
+    });
+    return {
+        relationships,
+        tableConnections: Object.fromEntries(Object.entries(tableConnections).map(([table, connections]) => [
+            table,
+            Array.from(connections)
+        ])),
+        totalRelationships: relationships.length,
+        compositeRelationships: relationships.filter(r => r.isComposite).length
+    };
+}
+function determineRelationshipType(updateRule, deleteRule) {
+    const ur = updateRule || 'NO ACTION';
+    const dr = deleteRule || 'NO ACTION';
+    if (ur === 'CASCADE' || dr === 'CASCADE') {
+        return 'strong_dependency'; // Child cannot exist without parent
+    }
+    else if (dr === 'RESTRICT' || dr === 'NO ACTION') {
+        return 'protective'; // Prevents accidental deletion
+    }
+    else if (dr === 'SET NULL') {
+        return 'optional_reference'; // Relationship can be broken
+    }
+    else {
+        return 'unknown';
+    }
+}
+function determineRelationshipStrength(updateRule, deleteRule) {
+    if (deleteRule === 'CASCADE' && updateRule === 'CASCADE') {
+        return 'strong';
+    }
+    else if (deleteRule === 'RESTRICT' || updateRule === 'RESTRICT') {
+        return 'medium';
+    }
+    else {
+        return 'weak';
+    }
+}
+function analyzeIntegrityRules(foreignKeys) {
+    const rules = {
+        cascade: {
+            delete: foreignKeys.filter(fk => fk.deleteRule === 'CASCADE'),
+            update: foreignKeys.filter(fk => fk.updateRule === 'CASCADE')
+        },
+        restrict: {
+            delete: foreignKeys.filter(fk => fk.deleteRule === 'RESTRICT' || fk.deleteRule === 'NO ACTION'),
+            update: foreignKeys.filter(fk => fk.updateRule === 'RESTRICT' || fk.updateRule === 'NO ACTION')
+        },
+        setNull: {
+            delete: foreignKeys.filter(fk => fk.deleteRule === 'SET NULL'),
+            update: foreignKeys.filter(fk => fk.updateRule === 'SET NULL')
+        }
+    };
+    return {
+        rules,
+        summary: {
+            cascadeDeleteTables: [...new Set(rules.cascade.delete.map(fk => fk.tableName))],
+            protectedTables: [...new Set(rules.restrict.delete.map(fk => fk.referencedTableName))],
+            weaklyReferencedTables: [...new Set(rules.setNull.delete.map(fk => fk.referencedTableName))]
+        }
+    };
+}
+function identifyPotentialIssues(foreignKeys) {
+    const issues = [];
+    // Check for circular references
+    const tableGraph = {};
+    foreignKeys.forEach(fk => {
+        if (!tableGraph[fk.tableName]) {
+            tableGraph[fk.tableName] = [];
+        }
+        tableGraph[fk.tableName].push(fk.referencedTableName);
+    });
+    // Simple cycle detection (this is a basic check, not comprehensive)
+    Object.keys(tableGraph).forEach(table => {
+        tableGraph[table].forEach(referenced => {
+            if (tableGraph[referenced] && tableGraph[referenced].includes(table)) {
+                issues.push(`Potential circular reference detected between tables '${table}' and '${referenced}'`);
+            }
+        });
+    });
+    // Check for many cascade delete relationships from same parent
+    const cascadeParents = {};
+    foreignKeys.filter(fk => fk.deleteRule === 'CASCADE').forEach(fk => {
+        cascadeParents[fk.referencedTableName] = (cascadeParents[fk.referencedTableName] || 0) + 1;
+    });
+    Object.entries(cascadeParents).forEach(([table, count]) => {
+        if (count > 5) {
+            issues.push(`Table '${table}' has ${count} cascade delete relationships - consider the impact of deletions`);
+        }
+    });
+    // Check for inconsistent naming patterns
+    const constraintNames = foreignKeys.map(fk => fk.constraintName);
+    const hasConsistentNaming = constraintNames.every(name => name.startsWith('fk_') || name.startsWith('FK_') ||
+        name.includes('_fk') || name.includes('_FK'));
+    if (!hasConsistentNaming && constraintNames.length > 1) {
+        issues.push('Foreign key constraint names follow inconsistent naming patterns');
+    }
+    return issues;
+}
+//# sourceMappingURL=get-foreign-keys.js.map