mcp-database-inspector 2.0.1

package/src/tools/analyze-query.test.ts

@@ -0,0 +1,100 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { handleAnalyzeQuery } from './analyze-query.js';
+import { DatabaseManager } from '../database/manager.js';
+
+describe('analyze_query', () => {
+  let mockDbManager: any;
+
+  beforeEach(() => {
+    mockDbManager = {
+      analyzeQuery: vi.fn()
+    };
+  });
+
+  it('should analyze a MySQL query and return execution plan', async () => {
+    const mockAnalysis = {
+      database: 'testdb',
+      type: 'MySQL',
+      query: 'SELECT * FROM users',
+      plan: { query_block: { cost_info: { query_cost: 1.5 } } },
+      summary: {
+        cost: 1.5,
+        operations: ['ALL'],
+        potentialIssues: ['Full table scan on users']
+      }
+    };
+
+    mockDbManager.analyzeQuery.mockResolvedValueOnce(mockAnalysis);
+
+    const result = await handleAnalyzeQuery(
+      { database: 'testdb', query: 'SELECT * FROM users' },
+      mockDbManager
+    );
+
+    const parsed = JSON.parse(result.content[0].text);
+    expect(parsed.summary.cost).toBe(1.5);
+    expect(parsed.summary.potentialIssues).toContain('Full table scan on users');
+    expect(parsed.summary.recommendation).toContain('potential performance issues');
+  });
+
+  it('should analyze a PostgreSQL query and return execution plan', async () => {
+    const mockAnalysis = {
+      database: 'testdb',
+      type: 'PostgreSQL',
+      query: 'SELECT * FROM products',
+      plan: { Plan: { 'Total Cost': 2.5, 'Node Type': 'Seq Scan' } },
+      summary: {
+        cost: 2.5,
+        operations: ['Seq Scan'],
+        potentialIssues: ['Full table scan on products']
+      }
+    };
+
+    mockDbManager.analyzeQuery.mockResolvedValueOnce(mockAnalysis);
+
+    const result = await handleAnalyzeQuery(
+      { database: 'testdb', query: 'SELECT * FROM products' },
+      mockDbManager
+    );
+
+    const parsed = JSON.parse(result.content[0].text);
+    expect(parsed.summary.cost).toBe(2.5);
+    expect(parsed.summary.operations).toContain('Seq Scan');
+  });
+
+  it('should return positive recommendation when no issues found', async () => {
+    const mockAnalysis = {
+      database: 'testdb',
+      type: 'MySQL',
+      query: 'SELECT * FROM users WHERE id = 1',
+      plan: { query_block: { cost_info: { query_cost: 0.35 } } },
+      summary: {
+        cost: 0.35,
+        operations: ['const'],
+        potentialIssues: []
+      }
+    };
+
+    mockDbManager.analyzeQuery.mockResolvedValueOnce(mockAnalysis);
+
+    const result = await handleAnalyzeQuery(
+      { database: 'testdb', query: 'SELECT * FROM users WHERE id = 1' },
+      mockDbManager
+    );
+
+    const parsed = JSON.parse(result.content[0].text);
+    expect(parsed.summary.recommendation).toContain('No major performance issues');
+  });
+
+  it('should throw error if neither database nor query is provided', async () => {
+    await expect(() =>
+      handleAnalyzeQuery({ database: 'testdb' }, mockDbManager)
+    ).rejects.toThrow(/Invalid arguments/);
+  });
+
+  it('should throw error for invalid database name', async () => {
+    await expect(() =>
+      handleAnalyzeQuery({ database: '', query: 'SELECT 1' }, mockDbManager)
+    ).rejects.toThrow(/Invalid arguments/);
+  });
+});

package/src/tools/analyze-query.ts

@@ -0,0 +1,112 @@
+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 } 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 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 const analyzeQueryToolDefinition: 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 async function handleAnalyzeQuery(
+  args: unknown,
+  dbManager: DatabaseManager
+): Promise<any> {
+  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
+    );
+  }
+}

package/src/tools/execute-query.ts

@@ -0,0 +1,91 @@
+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 } 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 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 const executeQueryToolDefinition: 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 async function handleExecuteQuery(
+  args: unknown,
+  dbManager: DatabaseManager
+): Promise<any> {
+  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
+    );
+  }
+}

package/src/tools/get-foreign-keys.test.ts

@@ -0,0 +1,51 @@
+// @ts-nocheck
+import { describe, it, expect, vi } from 'vitest';
+import { handleGetForeignKeys } from './get-foreign-keys';
+import { DatabaseManager } from '../database/manager';
+
+const mockDbManager = {
+  getForeignKeys: vi.fn()
+} as unknown as DatabaseManager;
+
+describe('get_foreign_keys', () => {
+  it('should return foreign keys for a single table', async () => {
+    mockDbManager.getForeignKeys.mockResolvedValueOnce([{ constraintName: 'fk_orders_users', tableName: 'orders', columnName: 'user_id', referencedTableName: 'users', referencedColumnName: 'id' }]);
+    const args = { database: 'testdb', table: 'orders' };
+    const result = await handleGetForeignKeys(args, mockDbManager);
+    const parsed = JSON.parse(result.content[0].text);
+    expect(parsed.table).toBe('orders');
+    expect(parsed.foreignKeys[0].sourceColumn).toBe('user_id');
+  });
+
+  it('should return foreign keys for multiple tables', async () => {
+    mockDbManager.getForeignKeys
+      .mockResolvedValueOnce([{ constraintName: 'fk_orders_users', tableName: 'orders', columnName: 'user_id', referencedTableName: 'users', referencedColumnName: 'id' }])
+      .mockResolvedValueOnce([{ constraintName: 'fk_items_orders', tableName: 'order_items', columnName: 'order_id', referencedTableName: 'orders', referencedColumnName: 'id' }]);
+    const args = { database: 'testdb', tables: ['orders', 'order_items'] };
+    const result = await handleGetForeignKeys(args, mockDbManager);
+    const parsed = JSON.parse(result.content[0].text);
+    expect(Object.keys(parsed.results)).toHaveLength(2);
+    expect(parsed.results.orders.table).toBe('orders');
+    expect(parsed.results.order_items.table).toBe('order_items');
+  });
+
+  it('should throw error if neither table nor tables is provided', async () => {
+    await expect(() =>
+      handleGetForeignKeys({ database: 'testdb' }, mockDbManager)
+    ).rejects.toThrow(/Either 'table' or non-empty 'tables'/);
+  });
+
+  it('should throw error for invalid table name', async () => {
+    await expect(() =>
+      handleGetForeignKeys({ database: 'testdb', table: 'invalid;DROP' }, mockDbManager)
+    ).rejects.toThrow(/Invalid table name/);
+  });
+
+  it('should return empty result if table not found', async () => {
+    mockDbManager.getForeignKeys.mockResolvedValueOnce([]);
+    const result = await handleGetForeignKeys({ database: 'testdb', table: 'notfound' }, mockDbManager);
+    const parsed = JSON.parse(result.content[0].text);
+    expect(parsed.foreignKeys).toHaveLength(0);
+    expect(parsed.summary.message).toMatch(/No foreign key relationships found/);
+  });
+});