mcp-database-inspector 2.0.1

package/src/tools/list-tables.ts

@@ -0,0 +1,181 @@
+import { z } from 'zod';
+import { DatabaseManager } from '../database/manager.js';
+import { InputValidator } from '../validators/input-validator.js';
+import { Logger } from '../utils/logger.js';
+import { ToolError, createErrorResponse } from '../utils/errors.js';
+
+// Tool schema
+const ListTablesArgsSchema = z.object({
+  database: z.string().min(1, 'Database name is required')
+});
+
+export interface ListTablesTool {
+  name: 'list_tables';
+  description: 'List all tables in the specified database with metadata';
+  inputSchema: {
+    type: 'object';
+    properties: {
+      database: {
+        type: 'string';
+        description: 'Name of the database to list tables from';
+      };
+    };
+    required: ['database'];
+  };
+}
+
+export const listTablesToolDefinition: ListTablesTool = {
+  name: 'list_tables',
+  description: 'List all tables in the specified database with metadata',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      database: {
+        type: 'string',
+        description: 'Name of the database to list tables from'
+      }
+    },
+    required: ['database']
+  }
+};
+
+export async function handleListTables(
+  args: unknown,
+  dbManager: DatabaseManager
+): Promise<any> {
+  try {
+    Logger.info('Executing list_tables tool');
+    
+    // Validate arguments
+    const validationResult = ListTablesArgsSchema.safeParse(args);
+    if (!validationResult.success) {
+      Logger.warn('Invalid arguments for list_tables', validationResult.error);
+      throw new ToolError(
+        `Invalid arguments: ${validationResult.error.issues.map(e => `${e.path.join('.')}: ${e.message}`).join(', ')}`,
+        'list_tables'
+      );
+    }
+
+    const { database } = validationResult.data;
+    
+    // Sanitize database name
+    const sanitizedDatabase = InputValidator.sanitizeString(database);
+    
+    // Validate database name format
+    const dbNameValidation = InputValidator.validateDatabaseName(sanitizedDatabase);
+    if (!dbNameValidation.isValid) {
+      throw new ToolError(
+        `Invalid database name: ${dbNameValidation.error}`,
+        'list_tables'
+      );
+    }
+
+    Logger.info(`Listing tables for database: ${sanitizedDatabase}`);
+    Logger.time('list_tables_execution');
+    
+    // Get tables from database
+    const tables = await dbManager.getTables(sanitizedDatabase);
+    
+    Logger.timeEnd('list_tables_execution');
+    Logger.info(`Found ${tables.length} tables in database: ${sanitizedDatabase}`);
+
+    // Group tables by type
+    const tablesByType = tables.reduce((acc, table) => {
+      const type = table.tableType;
+      if (!acc[type]) {
+        acc[type] = [];
+      }
+      acc[type].push(table);
+      return acc;
+    }, {} as Record<string, typeof tables>);
+
+    // Calculate statistics
+    const stats = {
+      totalTables: tables.length,
+      baseTables: (tablesByType['BASE TABLE'] || []).length,
+      views: (tablesByType['VIEW'] || []).length,
+      systemTables: (tablesByType['SYSTEM TABLE'] || []).length,
+      totalEstimatedRows: tables.reduce((sum, table) => sum + (table.tableRows || 0), 0)
+    };
+
+    // Format response
+    const response = {
+      database: sanitizedDatabase,
+      tables: tables.map(table => ({
+        name: table.tableName,
+        type: table.tableType,
+        engine: table.engine,
+        estimatedRows: table.tableRows,
+        comment: table.tableComment,
+        category: table.tableType === 'BASE TABLE' ? 'table' : 
+                 table.tableType === 'VIEW' ? 'view' : 
+                 'system'
+      })),
+      statistics: stats,
+      tablesByType: Object.keys(tablesByType).map(type => ({
+        type,
+        count: tablesByType[type].length,
+        tables: tablesByType[type].map(t => t.tableName)
+      })),
+      summary: {
+        hasData: tables.length > 0,
+        message: tables.length === 0 
+          ? `No tables found in database '${sanitizedDatabase}'. Database may be empty or inaccessible.`
+          : `Found ${tables.length} table(s) in database '${sanitizedDatabase}': ${stats.baseTables} base tables, ${stats.views} views.`
+      }
+    };
+
+    Logger.debug('list_tables completed successfully', {
+      database: sanitizedDatabase,
+      tableCount: tables.length,
+      baseTables: stats.baseTables,
+      views: stats.views
+    });
+
+    return {
+      content: [{
+        type: 'text',
+        text: JSON.stringify(response, null, 2)
+      }]
+    };
+
+  } catch (error) {
+    Logger.error('Error in list_tables tool', error);
+    
+    if (error instanceof ToolError) {
+      throw error;
+    }
+    
+    throw new ToolError(
+      `Failed to list tables: ${error instanceof Error ? error.message : 'Unknown error'}`,
+      'list_tables',
+      error instanceof Error ? error : undefined
+    );
+  }
+}
+
+export async function getTablesSummary(
+  dbManager: DatabaseManager, 
+  database: string
+): Promise<string> {
+  try {
+    const tables = await dbManager.getTables(database);
+    const baseTables = tables.filter(t => t.tableType === 'BASE TABLE').length;
+    const views = tables.filter(t => t.tableType === 'VIEW').length;
+    
+    if (tables.length === 0) {
+      return `Database '${database}' has no tables`;
+    }
+    
+    const parts = [];
+    if (baseTables > 0) parts.push(`${baseTables} table(s)`);
+    if (views > 0) parts.push(`${views} view(s)`);
+    
+    return `Database '${database}' contains ${parts.join(', ')}: ${
+      tables.slice(0, 5).map(t => t.tableName).join(', ')
+    }${tables.length > 5 ? `, and ${tables.length - 5} more` : ''}`;
+  } catch (error) {
+    Logger.error(`Error getting table summary for ${database}`, error);
+    return `Error retrieving tables for database '${database}'`;
+  }
+}

package/src/utils/errors.ts

@@ -0,0 +1,103 @@
+export class DatabaseError extends Error {
+  constructor(message: string, public readonly cause?: Error) {
+    super(message);
+    this.name = 'DatabaseError';
+    
+    if (cause) {
+      this.stack = `${this.stack}\nCaused by: ${cause.stack}`;
+    }
+  }
+}
+
+export class ValidationError extends Error {
+  constructor(message: string, public readonly field?: string) {
+    super(message);
+    this.name = 'ValidationError';
+  }
+}
+
+export class ConnectionError extends DatabaseError {
+  constructor(message: string, public readonly host?: string, public readonly port?: number, cause?: Error) {
+    super(message, cause);
+    this.name = 'ConnectionError';
+  }
+}
+
+export class QueryError extends DatabaseError {
+  constructor(message: string, public readonly query?: string, cause?: Error) {
+    super(message, cause);
+    this.name = 'QueryError';
+  }
+}
+
+export class ConfigurationError extends Error {
+  constructor(message: string, public readonly configKey?: string) {
+    super(message);
+    this.name = 'ConfigurationError';
+  }
+}
+
+export class ToolError extends Error {
+  constructor(message: string, public readonly toolName?: string, cause?: Error) {
+    super(message);
+    this.name = 'ToolError';
+    
+    if (cause) {
+      this.stack = `${this.stack}\nCaused by: ${cause.stack}`;
+    }
+  }
+}
+
+export function isRecoverableError(error: Error): boolean {
+  // Determine if an error is recoverable (temporary) or fatal
+  if (error instanceof ConnectionError) {
+    // Network timeouts, temporary connection issues
+    return error.message.includes('timeout') || 
+           error.message.includes('ECONNREFUSED') ||
+           error.message.includes('ENOTFOUND');
+  }
+  
+  if (error instanceof QueryError) {
+    // Syntax errors are not recoverable, but timeouts might be
+    return error.message.includes('timeout');
+  }
+  
+  return false;
+}
+
+export function sanitizeErrorMessage(error: Error): string {
+  // Remove sensitive information from error messages
+  let message = error.message;
+  
+  // Remove password information from connection strings
+  message = message.replace(/password=[^&\s]+/gi, 'password=***');
+  message = message.replace(/:([^@\s]+)@/g, ':***@');
+  
+  return message;
+}
+
+export function createErrorResponse(error: Error): { error: string; code?: string } {
+  const sanitized = sanitizeErrorMessage(error);
+  
+  if (error instanceof ValidationError) {
+    return { error: sanitized, code: 'VALIDATION_ERROR' };
+  }
+  
+  if (error instanceof ConnectionError) {
+    return { error: sanitized, code: 'CONNECTION_ERROR' };
+  }
+  
+  if (error instanceof QueryError) {
+    return { error: sanitized, code: 'QUERY_ERROR' };
+  }
+  
+  if (error instanceof DatabaseError) {
+    return { error: sanitized, code: 'DATABASE_ERROR' };
+  }
+  
+  if (error instanceof ToolError) {
+    return { error: sanitized, code: 'TOOL_ERROR' };
+  }
+  
+  return { error: sanitized, code: 'UNKNOWN_ERROR' };
+}

package/src/utils/logger.ts

@@ -0,0 +1,158 @@
+enum LogLevel {
+  ERROR = 0,
+  WARN = 1,
+  INFO = 2,
+  DEBUG = 3,
+  TRACE = 4
+}
+
+interface LogEntry {
+  timestamp: string;
+  level: string;
+  message: string;
+  data?: any;
+}
+
+export class Logger {
+  private static logLevel: LogLevel = LogLevel.INFO;
+  private static logs: LogEntry[] = [];
+  private static maxLogs = 1000;
+
+  static setLogLevel(level: 'error' | 'warn' | 'info' | 'debug' | 'trace'): void {
+    const levelMap = {
+      error: LogLevel.ERROR,
+      warn: LogLevel.WARN,
+      info: LogLevel.INFO,
+      debug: LogLevel.DEBUG,
+      trace: LogLevel.TRACE
+    };
+    this.logLevel = levelMap[level] ?? LogLevel.INFO;
+  }
+
+  static getLogLevel(): string {
+    const levelNames = ['error', 'warn', 'info', 'debug', 'trace'];
+    return levelNames[this.logLevel] || 'info';
+  }
+
+  private static shouldLog(level: LogLevel): boolean {
+    return level <= this.logLevel;
+  }
+
+  private static addLog(level: string, message: string, data?: any): void {
+    const entry: LogEntry = {
+      timestamp: new Date().toISOString(),
+      level,
+      message,
+      data
+    };
+
+    this.logs.push(entry);
+
+    // Keep only the most recent logs
+    if (this.logs.length > this.maxLogs) {
+      this.logs = this.logs.slice(-this.maxLogs);
+    }
+
+    // Output to stderr to avoid interfering with MCP protocol on stdout
+    const logMessage = this.formatLog(entry);
+    console.error(logMessage);
+  }
+
+  private static formatLog(entry: LogEntry): string {
+    const timestamp = entry.timestamp.split('T')[1].split('.')[0]; // HH:MM:SS format
+    let message = `[${timestamp}] ${entry.level.toUpperCase()}: ${entry.message}`;
+    
+    if (entry.data !== undefined) {
+      message += ` ${JSON.stringify(entry.data)}`;
+    }
+    
+    return message;
+  }
+
+  static error(message: string, data?: any): void {
+    if (this.shouldLog(LogLevel.ERROR)) {
+      this.addLog('error', message, data);
+    }
+  }
+
+  static warn(message: string, data?: any): void {
+    if (this.shouldLog(LogLevel.WARN)) {
+      this.addLog('warn', message, data);
+    }
+  }
+
+  static info(message: string, data?: any): void {
+    if (this.shouldLog(LogLevel.INFO)) {
+      this.addLog('info', message, data);
+    }
+  }
+
+  static debug(message: string, data?: any): void {
+    if (this.shouldLog(LogLevel.DEBUG)) {
+      this.addLog('debug', message, data);
+    }
+  }
+
+  static trace(message: string, data?: any): void {
+    if (this.shouldLog(LogLevel.TRACE)) {
+      this.addLog('trace', message, data);
+    }
+  }
+
+  static getLogs(limit?: number): LogEntry[] {
+    if (limit && limit > 0) {
+      return this.logs.slice(-limit);
+    }
+    return [...this.logs];
+  }
+
+  static clearLogs(): void {
+    this.logs = [];
+  }
+
+  // Performance timing utilities
+  static time(label: string): void {
+    if (this.shouldLog(LogLevel.DEBUG)) {
+      console.time(`[TIMER] ${label}`);
+    }
+  }
+
+  static timeEnd(label: string): void {
+    if (this.shouldLog(LogLevel.DEBUG)) {
+      console.timeEnd(`[TIMER] ${label}`);
+    }
+  }
+
+  // Safe logging that won't throw errors
+  static safeLog(level: 'error' | 'warn' | 'info' | 'debug' | 'trace', message: string, data?: any): void {
+    try {
+      switch (level) {
+        case 'error':
+          this.error(message, data);
+          break;
+        case 'warn':
+          this.warn(message, data);
+          break;
+        case 'info':
+          this.info(message, data);
+          break;
+        case 'debug':
+          this.debug(message, data);
+          break;
+        case 'trace':
+          this.trace(message, data);
+          break;
+      }
+    } catch (error) {
+      // Fallback to console.error if our logging fails
+      console.error(`Logging failed: ${error instanceof Error ? error.message : 'Unknown error'}`);
+      console.error(`Original message: ${message}`);
+    }
+  }
+}
+
+// Initialize from environment variable
+const envLogLevel = process.env.LOG_LEVEL?.toLowerCase();
+if (envLogLevel && ['error', 'warn', 'info', 'debug', 'trace'].includes(envLogLevel)) {
+  Logger.setLogLevel(envLogLevel as any);
+}