@hyqf98/easy_db_mcp_server 1.0.0 → 2.0.0

package/src/index.ts

@@ -1,19 +1,16 @@
 #!/usr/bin/env node
-import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
-import {
-  CallToolRequestSchema,
-  ListToolsRequestSchema,
-} from '@modelcontextprotocol/sdk/types.js';
+import { z } from 'zod';
 import { loadConfig } from './config.js';
 import { createAdapter } from './database/factory.js';
 import type { DatabaseAdapter } from './database/base.js';
 
-// Create server instance
-const server = new Server(
+// Create server instance with new API
+const server = new McpServer(
   {
     name: 'hyqf98@easy_db_mcp_server',
-    version: '1.0.0',
+    version: '2.0.0',
   },
   {
     capabilities: {
@@ -24,223 +21,341 @@ const server = new Server(
 
 // Load configuration and create adapter
 let adapter: DatabaseAdapter;
+let cachedConfig: ReturnType<typeof loadConfig>;
 
 try {
-  const config = loadConfig();
-  adapter = createAdapter(config);
+  cachedConfig = loadConfig();
+  adapter = createAdapter(cachedConfig);
   await adapter.connect();
-  console.error(`Connected to ${config.type} database`);
+  console.error(`Connected to ${cachedConfig.type} database`);
 } catch (error) {
   console.error('Failed to connect to database:', error);
   process.exit(1);
 }
 
-// List available tools
-server.setRequestHandler(ListToolsRequestSchema, async () => {
-  return {
-    tools: [
-      {
-        name: 'list_tables',
-        description: 'List all tables in the database. If EASYDB_DATABASE is not set, the database parameter must be provided.',
-        inputSchema: {
-          type: 'object',
-          properties: {
-            database: {
-              type: 'string',
-              description: 'Database name (optional if EASYDB_DATABASE is set, otherwise required)',
-            },
-          },
-        },
-      },
-      {
-        name: 'describe_table',
-        description: 'Get the structure of a table including columns, types, and constraints. If EASYDB_DATABASE is not set, the database parameter must be provided.',
-        inputSchema: {
-          type: 'object',
-          properties: {
-            table: {
-              type: 'string',
-              description: 'Table name',
-            },
-            database: {
-              type: 'string',
-              description: 'Database name (optional if EASYDB_DATABASE is set, otherwise required)',
-            },
-          },
-          required: ['table'],
-        },
-      },
-      {
-        name: 'execute_query',
-        description: 'Execute a SELECT query (read-only). If EASYDB_DATABASE is not set, the database parameter must be provided.',
-        inputSchema: {
-          type: 'object',
-          properties: {
-            sql: {
-              type: 'string',
-              description: 'SQL SELECT query to execute',
-            },
-            database: {
-              type: 'string',
-              description: 'Database name (optional if EASYDB_DATABASE is set, otherwise required)',
-            },
-          },
-          required: ['sql'],
-        },
-      },
-      {
-        name: 'execute_sql',
-        description: 'Execute any SQL statement (requires EASYDB_ALLOW_WRITE=true). If EASYDB_DATABASE is not set, the database parameter must be provided.',
-        inputSchema: {
-          type: 'object',
-          properties: {
-            sql: {
-              type: 'string',
-              description: 'SQL statement to execute (INSERT, UPDATE, DELETE, DDL, etc.)',
-            },
-            database: {
-              type: 'string',
-              description: 'Database name (optional if EASYDB_DATABASE is set, otherwise required)',
-            },
-          },
-          required: ['sql'],
-        },
-      },
-    ],
-  };
-});
+// Helper function to validate database parameter
+const getDatabase = (paramDb?: string): string => {
+  if (paramDb) {
+    return paramDb;
+  }
+  if (cachedConfig.database) {
+    return cachedConfig.database;
+  }
+  throw new Error(
+    'Database name is required. Either set EASYDB_DATABASE environment variable or pass the database parameter in the tool call.'
+  );
+};
 
-// Handle tool calls
-server.setRequestHandler(CallToolRequestSchema, async (request) => {
-  const { name, arguments: args } = request.params;
-  const config = loadConfig();
+// Register existing tools with new API
+server.registerTool(
+  'list_tables',
+  {
+    title: 'List Tables',
+    description: 'List all tables in the database. If EASYDB_DATABASE is not set, the database parameter must be provided.',
+    inputSchema: {
+      database: z.string().optional().describe('Database name (optional if EASYDB_DATABASE is set, otherwise required)'),
+    },
+  },
+  async ({ database }) => {
+    const dbName = getDatabase(database);
+    const tables = await adapter.listTables(dbName);
+    return {
+      content: [{ type: 'text', text: JSON.stringify(tables, null, 2) }],
+    };
+  }
+);
 
-  // Helper function to validate database parameter
-  const getDatabase = (paramDb?: string): string => {
-    if (paramDb) {
-      return paramDb;
+server.registerTool(
+  'describe_table',
+  {
+    title: 'Describe Table',
+    description: 'Get the structure of a table including columns, types, and constraints. If EASYDB_DATABASE is not set, the database parameter must be provided.',
+    inputSchema: {
+      table: z.string().describe('Table name'),
+      database: z.string().optional().describe('Database name (optional if EASYDB_DATABASE is set, otherwise required)'),
+    },
+  },
+  async ({ table, database }) => {
+    const dbName = getDatabase(database);
+    const columns = await adapter.describeTable(table, dbName);
+    return {
+      content: [{ type: 'text', text: JSON.stringify(columns, null, 2) }],
+    };
+  }
+);
+
+server.registerTool(
+  'execute_query',
+  {
+    title: 'Execute Query',
+    description: 'Execute a SELECT query (read-only). If EASYDB_DATABASE is not set, the database parameter must be provided.',
+    inputSchema: {
+      sql: z.string().describe('SQL SELECT query to execute'),
+      database: z.string().optional().describe('Database name (optional if EASYDB_DATABASE is set, otherwise required)'),
+    },
+  },
+  async ({ sql, database }) => {
+    const dbName = getDatabase(database);
+    const result = await adapter.executeQuery(sql, dbName);
+    return {
+      content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+    };
+  }
+);
+
+server.registerTool(
+  'execute_sql',
+  {
+    title: 'Execute SQL',
+    description: 'Execute any SQL statement (requires EASYDB_ALLOW_WRITE=true). If EASYDB_DATABASE is not set, the database parameter must be provided.',
+    inputSchema: {
+      sql: z.string().describe('SQL statement to execute (INSERT, UPDATE, DELETE, DDL, etc.)'),
+      database: z.string().optional().describe('Database name (optional if EASYDB_DATABASE is set, otherwise required)'),
+    },
+  },
+  async ({ sql, database }) => {
+    if (!cachedConfig.allowWrite) {
+      throw new Error(
+        'SQL execution requires EASYDB_ALLOW_WRITE=true for safety. Please enable this environment variable if you want to allow write operations.'
+      );
     }
-    if (config.database) {
-      return config.database;
+
+    // Improved DDL detection using regex to handle various formats
+    const trimmed = sql.trim().toUpperCase();
+    const ddlPattern = /^(CREATE|DROP|ALTER|TRUNCATE|RENAME)\s+(TABLE|INDEX|DATABASE|SCHEMA|VIEW|PROCEDURE|FUNCTION|TRIGGER)/;
+    const isDDL = ddlPattern.test(trimmed);
+
+    if (isDDL && !cachedConfig.allowDDL) {
+      throw new Error(
+        'DDL statements require EASYDB_ALLOW_DDL=true for safety. Please enable this environment variable if you want to allow DDL operations.'
+      );
+    }
+
+    const dbName = getDatabase(database);
+    const result = await adapter.executeSQL(sql, dbName);
+    return {
+      content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+    };
+  }
+);
+
+server.registerTool(
+  'execute_transaction',
+  {
+    title: 'Execute Transaction',
+    description: 'Execute multiple SQL statements as a transaction. All queries will succeed or all will be rolled back.',
+    inputSchema: {
+      sql: z.array(z.string()).max(100).describe('Array of SQL statements to execute in transaction (max 100)'),
+      database: z.string().optional().describe('Database name (optional if EASYDB_DATABASE is set)'),
+    },
+  },
+  async ({ sql, database }) => {
+    if (!cachedConfig.allowWrite) {
+      throw new Error('Transaction execution requires EASYDB_ALLOW_WRITE=true');
     }
-    throw new Error(
-      'Database name is required. Either set EASYDB_DATABASE environment variable or pass the database parameter in the tool call.'
-    );
-  };
 
-  try {
-    switch (name) {
-      case 'list_tables': {
-        const database = getDatabase(args?.database as string | undefined);
-        const tables = await adapter.listTables(database);
-        return {
-          content: [
-            {
-              type: 'text',
-              text: JSON.stringify(tables, null, 2),
-            },
-          ],
-        };
-      }
+    const dbName = getDatabase(database);
+    const result = await adapter.executeTransaction(sql, dbName);
+    return {
+      content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+    };
+  }
+);
 
-      case 'describe_table': {
-        const database = getDatabase(args?.database as string | undefined);
-        const columns = await adapter.describeTable(
-          args?.table as string,
-          database
-        );
-        return {
-          content: [
-            {
-              type: 'text',
-              text: JSON.stringify(columns, null, 2),
-            },
-          ],
-        };
-      }
+server.registerTool(
+  'batch_insert',
+  {
+    title: 'Batch Insert',
+    description: 'Insert multiple rows into a table efficiently',
+    inputSchema: {
+      table: z.string().describe('Table name'),
+      data: z.array(z.record(z.string(), z.any())).describe('Array of row data objects'),
+      database: z.string().optional().describe('Database name (optional if EASYDB_DATABASE is set)'),
+    },
+  },
+  async ({ table, data, database }) => {
+    if (!cachedConfig.allowWrite) {
+      throw new Error('Batch insert requires EASYDB_ALLOW_WRITE=true');
+    }
 
-      case 'execute_query': {
-        const database = getDatabase(args?.database as string | undefined);
-        const result = await adapter.executeQuery(
-          args?.sql as string,
-          database
-        );
-        return {
-          content: [
-            {
-              type: 'text',
-              text: JSON.stringify(result, null, 2),
-            },
-          ],
-        };
-      }
+    const dbName = getDatabase(database);
+    const result = await adapter.batchInsert(table, data, dbName);
+    return {
+      content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+    };
+  }
+);
 
-      case 'execute_sql': {
-        if (!config.allowWrite) {
-          throw new Error(
-            'SQL execution requires EASYDB_ALLOW_WRITE=true for safety. Please enable this environment variable if you want to allow write operations.'
-          );
-        }
+server.registerTool(
+  'batch_update',
+  {
+    title: 'Batch Update',
+    description: 'Update multiple rows in a table based on conditions',
+    inputSchema: {
+      table: z.string().describe('Table name'),
+      updates: z.object({
+        set: z.record(z.string(), z.any()).describe('Column values to set'),
+        where: z.string().describe('WHERE clause condition'),
+      }),
+      database: z.string().optional().describe('Database name (optional if EASYDB_DATABASE is set)'),
+    },
+  },
+  async ({ table, updates, database }) => {
+    if (!cachedConfig.allowWrite) {
+      throw new Error('Batch update requires EASYDB_ALLOW_WRITE=true');
+    }
 
-        const sql = args?.sql as string;
-        const trimmed = sql.trim().toUpperCase();
+    const dbName = getDatabase(database);
+    const result = await adapter.batchUpdate(table, updates, dbName);
+    return {
+      content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+    };
+  }
+);
 
-        // Check for DDL statements
-        const isDDL =
-          trimmed.startsWith('CREATE ') ||
-          trimmed.startsWith('DROP ') ||
-          trimmed.startsWith('ALTER ') ||
-          trimmed.startsWith('TRUNCATE ');
+server.registerTool(
+  'export_data',
+  {
+    title: 'Export Data',
+    description: 'Export table data to JSON or CSV file. Default saves to ~/table_name.json',
+    inputSchema: {
+      table: z.string().describe('Table name to export'),
+      format: z.enum(['json', 'csv']).describe('Export format'),
+      filePath: z.string().optional().describe('Optional file path (default: ~/table_name.format)'),
+      limit: z.number().optional().describe('Optional row limit'),
+      where: z.string().optional().describe('Optional WHERE clause'),
+      database: z.string().optional().describe('Database name (optional if EASYDB_DATABASE is set)'),
+    },
+  },
+  async ({ table, format, filePath, limit, where, database }) => {
+    const dbName = getDatabase(database);
+    const result = await adapter.exportData(table, format, filePath, { limit, where }, dbName);
+    return {
+      content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+    };
+  }
+);
 
-        if (isDDL && !config.allowDDL) {
-          throw new Error(
-            'DDL statements require EASYDB_ALLOW_DDL=true for safety. Please enable this environment variable if you want to allow DDL operations.'
-          );
-        }
+server.registerTool(
+  'create_table',
+  {
+    title: 'Create Table',
+    description: 'Create a new table with specified columns',
+    inputSchema: {
+      table: z.string().describe('Table name'),
+      columns: z.array(z.object({
+        name: z.string().describe('Column name'),
+        type: z.string().describe('Column data type'),
+        nullable: z.boolean().optional().describe('Whether column allows NULL'),
+        primaryKey: z.boolean().optional().describe('Whether column is primary key'),
+        defaultValue: z.any().optional().describe('Default value'),
+      })).describe('Column definitions'),
+      database: z.string().optional().describe('Database name (optional if EASYDB_DATABASE is set)'),
+    },
+  },
+  async ({ table, columns, database }) => {
+    if (!cachedConfig.allowDDL) {
+      throw new Error('Create table requires EASYDB_ALLOW_DDL=true');
+    }
 
-        const database = getDatabase(args?.database as string | undefined);
-        const result = await adapter.executeSQL(
-          sql,
-          database
-        );
-        return {
-          content: [
-            {
-              type: 'text',
-              text: JSON.stringify(result, null, 2),
-            },
-          ],
-        };
-      }
+    const dbName = getDatabase(database);
+    const result = await adapter.createTable(table, columns, dbName);
+    return {
+      content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+    };
+  }
+);
 
-      default:
-        throw new Error(`Unknown tool: ${name}`);
+server.registerTool(
+  'drop_table',
+  {
+    title: 'Drop Table',
+    description: 'Delete a table from the database',
+    inputSchema: {
+      table: z.string().describe('Table name to drop'),
+      ifExists: z.boolean().optional().describe('Use IF EXISTS to avoid error if table does not exist'),
+      database: z.string().optional().describe('Database name (optional if EASYDB_DATABASE is set)'),
+    },
+  },
+  async ({ table, ifExists, database }) => {
+    if (!cachedConfig.allowDDL) {
+      throw new Error('Drop table requires EASYDB_ALLOW_DDL=true');
     }
-  } catch (error) {
+
+    const dbName = getDatabase(database);
+    const result = await adapter.dropTable(table, ifExists, dbName);
     return {
-      content: [
-        {
-          type: 'text',
-          text: JSON.stringify(
-            {
-              success: false,
-              error: error instanceof Error ? error.message : String(error),
-            },
-            null,
-            2
-          ),
-        },
-      ],
-      isError: true,
+      content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
     };
   }
-});
+);
+
+server.registerTool(
+  'get_table_stats',
+  {
+    title: 'Get Table Statistics',
+    description: 'Get detailed statistics about a table including row count, columns, indexes, and size',
+    inputSchema: {
+      table: z.string().describe('Table name'),
+      database: z.string().optional().describe('Database name (optional if EASYDB_DATABASE is set)'),
+    },
+  },
+  async ({ table, database }) => {
+    const dbName = getDatabase(database);
+    const result = await adapter.getTableStats(table, dbName);
+    return {
+      content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+    };
+  }
+);
+
+server.registerTool(
+  'preview_data',
+  {
+    title: 'Preview Data',
+    description: 'Preview table data with pagination',
+    inputSchema: {
+      table: z.string().describe('Table name'),
+      page: z.number().optional().describe('Page number (default: 1)'),
+      pageSize: z.number().optional().describe('Rows per page (default: 50)'),
+      orderBy: z.string().optional().describe('Order by column name'),
+      database: z.string().optional().describe('Database name (optional if EASYDB_DATABASE is set)'),
+    },
+  },
+  async ({ table, page = 1, pageSize = 50, orderBy, database }) => {
+    const dbName = getDatabase(database);
+    const result = await adapter.previewData(table, page, pageSize, orderBy, dbName);
+    return {
+      content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+    };
+  }
+);
+
+server.registerTool(
+  'sample_data',
+  {
+    title: 'Sample Data',
+    description: 'Get a random sample of rows from a table',
+    inputSchema: {
+      table: z.string().describe('Table name'),
+      count: z.number().optional().describe('Number of rows to sample (default: 10)'),
+      database: z.string().optional().describe('Database name (optional if EASYDB_DATABASE is set)'),
+    },
+  },
+  async ({ table, count = 10, database }) => {
+    const dbName = getDatabase(database);
+    const result = await adapter.sampleData(table, count, dbName);
+    return {
+      content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+    };
+  }
+);
 
 // Start server
 async function main() {
   const transport = new StdioServerTransport();
   await server.connect(transport);
-  console.error('EasyDB MCP Server running');
+  console.error('EasyDB MCP Server v2.0.0 running');
 }
 
 main().catch((error) => {

package/src/utils/file.ts

@@ -0,0 +1,46 @@
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+
+const homedir = os.homedir();
+
+export function expandTilde(filePath: string): string {
+  if (filePath.startsWith('~')) {
+    return path.join(homedir, filePath.slice(1));
+  }
+  return filePath;
+}
+
+export function formatFileSize(bytes: number): string {
+  const units = ['B', 'KB', 'MB', 'GB'];
+  let size = bytes;
+  let unitIndex = 0;
+
+  while (size >= 1024 && unitIndex < units.length - 1) {
+    size /= 1024;
+    unitIndex++;
+  }
+
+  return size.toFixed(2) + ' ' + units[unitIndex];
+}
+
+export function ensureDirectoryExists(filePath: string): void {
+  const dir = path.dirname(filePath);
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+}
+
+export function getDefaultFilePath(baseName: string, extension: string): string {
+  const timestamp = new Date().toISOString().replace(/[:.]/g, '-').split('T')[0];
+  const time = new Date().toTimeString().split(' ')[0].replace(/:/g, '');
+  let fileName = baseName + '.' + extension;
+
+  // Check if file exists, add timestamp if it does
+  const fullPath = path.join(homedir, fileName);
+  if (fs.existsSync(fullPath)) {
+    fileName = baseName + '_' + timestamp + '_' + time + '.' + extension;
+  }
+
+  return path.join(homedir, fileName);
+}