@hyqf98/easy_db_mcp_server 1.0.0 → 2.0.0

package/dist/utils/file.js

@@ -0,0 +1,37 @@
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+const homedir = os.homedir();
+export function expandTilde(filePath) {
+    if (filePath.startsWith('~')) {
+        return path.join(homedir, filePath.slice(1));
+    }
+    return filePath;
+}
+export function formatFileSize(bytes) {
+    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) {
+    const dir = path.dirname(filePath);
+    if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+    }
+}
+export function getDefaultFilePath(baseName, extension) {
+    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);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hyqf98/easy_db_mcp_server",
-  "version": "1.0.0",
+  "version": "2.0.0",
   "description": "MCP server for database access (MySQL, PostgreSQL, SQLite)",
   "type": "module",
   "bin": {

package/src/database/base.ts

@@ -5,16 +5,99 @@ export interface TableColumn {
   defaultValue: string | null;
   primaryKey: boolean;
   extra?: string;
+  [key: string]: unknown; // Index signature for structuredContent
 }
 
 export interface TableInfo {
   name: string;
   rowCount?: number;
+  [key: string]: unknown; // Index signature for structuredContent
 }
 
 export interface QueryResult {
   rows: Record<string, unknown>[];
   rowCount: number;
+  [key: string]: unknown; // Index signature for structuredContent
+}
+
+// New type definitions for v2 features
+export interface BatchInsertResult {
+  insertedRows: number;
+  duplicateRows: number;
+  [key: string]: unknown;
+}
+
+export interface BatchUpdateOptions {
+  set: Record<string, unknown>;
+  where: string;
+}
+
+export interface BatchUpdateResult {
+  affectedRows: number;
+  [key: string]: unknown;
+}
+
+export interface TransactionResult {
+  success: boolean;
+  affectedRows: number;
+  results: unknown[];
+  [key: string]: unknown;
+}
+
+export interface ExportOptions {
+  limit?: number;
+  where?: string;
+}
+
+export interface ExportResult {
+  success: boolean;
+  filePath: string;
+  rowCount: number;
+  fileSize: string;
+  [key: string]: unknown;
+}
+
+export interface TableColumnDef {
+  name: string;
+  type: string;
+  nullable?: boolean;
+  primaryKey?: boolean;
+  defaultValue?: unknown;
+}
+
+export interface CreateTableResult {
+  success: boolean;
+  tableName: string;
+  [key: string]: unknown;
+}
+
+export interface DropTableResult {
+  success: boolean;
+  tableName: string;
+  [key: string]: unknown;
+}
+
+export interface TableStatsResult {
+  tableName: string;
+  rowCount: number;
+  columns: number;
+  indexes: string[];
+  size: string;
+  [key: string]: unknown;
+}
+
+export interface PreviewDataResult {
+  rows: Record<string, unknown>[];
+  currentPage: number;
+  totalPages: number;
+  totalRows: number;
+  [key: string]: unknown;
+}
+
+export interface SampleDataResult {
+  rows: Record<string, unknown>[];
+  sampleCount: number;
+  [key: string]: unknown;
 }
 
 export interface DatabaseAdapter {
@@ -47,4 +130,21 @@ export interface DatabaseAdapter {
    * Close the database connection
    */
   close(): Promise<void>;
+
+  // New methods - batch operations
+  batchInsert(table: string, data: Record<string, unknown>[], database?: string): Promise<BatchInsertResult>;
+  batchUpdate(table: string, updates: BatchUpdateOptions, database?: string): Promise<BatchUpdateResult>;
+  executeTransaction(queries: string[], database?: string): Promise<TransactionResult>;
+
+  // New methods - data export
+  exportData(table: string, format: 'json' | 'csv', filePath?: string, options?: ExportOptions, database?: string): Promise<ExportResult>;
+
+  // New methods - table management
+  createTable(table: string, columns: TableColumnDef[], database?: string): Promise<CreateTableResult>;
+  dropTable(table: string, ifExists?: boolean, database?: string): Promise<DropTableResult>;
+
+  // New methods - analytics
+  getTableStats(table: string, database?: string): Promise<TableStatsResult>;
+  previewData(table: string, page?: number, pageSize?: number, orderBy?: string, database?: string): Promise<PreviewDataResult>;
+  sampleData(table: string, count?: number, database?: string): Promise<SampleDataResult>;
 }

package/src/database/mysql.ts

@@ -1,11 +1,25 @@
 import mysql from 'mysql2/promise';
+import fs from 'fs';
 import type {
   DatabaseAdapter,
   TableInfo,
   TableColumn,
   QueryResult,
+  TransactionResult,
+  BatchInsertResult,
+  BatchUpdateResult,
+  BatchUpdateOptions,
+  ExportResult,
+  ExportOptions,
+  CreateTableResult,
+  DropTableResult,
+  TableColumnDef,
+  TableStatsResult,
+  PreviewDataResult,
+  SampleDataResult,
 } from './base.js';
 import type { DatabaseConfig } from '../config.js';
+import { expandTilde, formatFileSize, ensureDirectoryExists, getDefaultFilePath } from '../utils/file.js';
 
 export class MySQLAdapter implements DatabaseAdapter {
   private pool?: mysql.Pool;
@@ -81,38 +95,58 @@ export class MySQLAdapter implements DatabaseAdapter {
   async executeQuery(sql: string, database?: string): Promise<QueryResult> {
     if (!this.pool) throw new Error('Not connected');
 
-    // If database is specified and different from config, we need to handle it
-    // For now, we'll allow queries to use fully qualified table names
-    // Verify it's a SELECT query
     const trimmed = sql.trim().toUpperCase();
     if (!trimmed.startsWith('SELECT')) {
       throw new Error('Only SELECT queries allowed in executeQuery');
     }
 
-    const [rows] = await this.pool.query(sql);
+    // Get a connection from the pool to handle database switching
+    const connection = await this.pool.getConnection();
+
+    try {
+      // Switch to the specified database if provided
+      if (database && database !== this.config.database) {
+        await connection.query(`USE ${mysql.escapeId(database)}`);
+      }
 
-    return {
-      rows: rows as Record<string, unknown>[],
-      rowCount: Array.isArray(rows) ? rows.length : 0,
-    };
+      const [rows] = await connection.query(sql);
+
+      return {
+        rows: rows as Record<string, unknown>[],
+        rowCount: Array.isArray(rows) ? rows.length : 0,
+      };
+    } finally {
+      connection.release();
+    }
   }
 
   async executeSQL(sql: string, database?: string): Promise<QueryResult | { affectedRows: number }> {
     if (!this.pool) throw new Error('Not connected');
 
-    // Allow SQL execution with database-specific queries
-    const [result] = await this.pool.query(sql);
+    // Get a connection from the pool to handle database switching
+    const connection = await this.pool.getConnection();
 
-    // @ts-ignore - MySQL result structure
-    if (result.affectedRows !== undefined) {
-      // @ts-ignore
-      return { affectedRows: result.affectedRows };
-    }
+    try {
+      // Switch to the specified database if provided
+      if (database && database !== this.config.database) {
+        await connection.query(`USE ${mysql.escapeId(database)}`);
+      }
+
+      const [result] = await connection.query(sql);
 
-    return {
-      rows: result as Record<string, unknown>[],
-      rowCount: Array.isArray(result) ? result.length : 0,
-    };
+      // @ts-ignore - MySQL result structure
+      if (result.affectedRows !== undefined) {
+        // @ts-ignore
+        return { affectedRows: result.affectedRows };
+      }
+
+      return {
+        rows: result as Record<string, unknown>[],
+        rowCount: Array.isArray(result) ? result.length : 0,
+      };
+    } finally {
+      connection.release();
+    }
   }
 
   async close(): Promise<void> {
@@ -121,4 +155,379 @@ export class MySQLAdapter implements DatabaseAdapter {
       this.pool = undefined;
     }
   }
+
+  async executeTransaction(queries: string[], database?: string): Promise<TransactionResult> {
+    if (!this.pool) throw new Error('Not connected');
+
+    const connection = await this.pool.getConnection();
+
+    try {
+      // Switch to specified database if needed
+      if (database && database !== this.config.database) {
+        await connection.query(`USE ${mysql.escapeId(database)}`);
+      }
+
+      await connection.beginTransaction();
+
+      const results: unknown[] = [];
+      let totalAffectedRows = 0;
+
+      for (const query of queries) {
+        const [result] = await connection.query(query);
+
+        // @ts-ignore - MySQL result structure
+        if (result.affectedRows !== undefined) {
+          // @ts-ignore
+          totalAffectedRows += result.affectedRows;
+        }
+
+        results.push(result);
+      }
+
+      await connection.commit();
+
+      return {
+        success: true,
+        affectedRows: totalAffectedRows,
+        results,
+      };
+    } catch (error) {
+      await connection.rollback();
+      throw error;
+    } finally {
+      connection.release();
+    }
+  }
+
+  async batchInsert(
+    table: string,
+    data: Record<string, unknown>[],
+    database?: string
+  ): Promise<BatchInsertResult> {
+    if (!this.pool) throw new Error('Not connected');
+
+    if (data.length === 0) {
+      return { insertedRows: 0, duplicateRows: 0 };
+    }
+
+    const connection = await this.pool.getConnection();
+
+    try {
+      if (database && database !== this.config.database) {
+        await connection.query(`USE ${mysql.escapeId(database)}`);
+      }
+
+      // Build bulk insert query
+      const columns = Object.keys(data[0]);
+      const placeholders = columns.map(() => '?').join(', ');
+      const columnList = columns.map((c) => mysql.escapeId(c)).join(', ');
+
+      const query = `INSERT INTO ${mysql.escapeId(table)} (${columnList}) VALUES (${placeholders})`;
+
+      let insertedRows = 0;
+      let duplicateRows = 0;
+
+      for (const row of data) {
+        try {
+          const values = columns.map((col) => row[col]);
+          await connection.query(query, values);
+          insertedRows++;
+        } catch (error: any) {
+          // Check for duplicate key error
+          if (error.code === 'ER_DUP_ENTRY') {
+            duplicateRows++;
+          } else {
+            throw error;
+          }
+        }
+      }
+
+      return { insertedRows, duplicateRows };
+    } finally {
+      connection.release();
+    }
+  }
+
+  async batchUpdate(
+    table: string,
+    updates: BatchUpdateOptions,
+    database?: string
+  ): Promise<BatchUpdateResult> {
+    if (!this.pool) throw new Error('Not connected');
+
+    const connection = await this.pool.getConnection();
+
+    try {
+      if (database && database !== this.config.database) {
+        await connection.query(`USE ${mysql.escapeId(database)}`);
+      }
+
+      // Build SET clause
+      const setClause = Object.entries(updates.set)
+        .map(([key, value]) => `${mysql.escapeId(key)} = ${this.escapeValue(value)}`)
+        .join(', ');
+
+      const query = `UPDATE ${mysql.escapeId(table)} SET ${setClause} WHERE ${updates.where}`;
+
+      const [result] = await connection.query(query);
+
+      // @ts-ignore
+      return { affectedRows: result.affectedRows || 0 };
+    } finally {
+      connection.release();
+    }
+  }
+
+  private escapeValue(value: unknown): string {
+    if (value === null) return 'NULL';
+    if (typeof value === 'number') return String(value);
+    if (typeof value === 'boolean') return value ? '1' : '0';
+    return mysql.escape(String(value));
+  }
+
+  async exportData(
+    table: string,
+    format: 'json' | 'csv',
+    filePath?: string,
+    options?: ExportOptions,
+    database?: string
+  ): Promise<ExportResult> {
+    if (!this.pool) throw new Error('Not connected');
+
+    const connection = await this.pool.getConnection();
+
+    try {
+      if (database && database !== this.config.database) {
+        await connection.query(`USE ${mysql.escapeId(database)}`);
+      }
+
+      // Build query
+      let query = `SELECT * FROM ${mysql.escapeId(table)}`;
+      if (options?.where) {
+        query += ` WHERE ${options.where}`;
+      }
+      if (options?.limit) {
+        query += ` LIMIT ${options.limit}`;
+      }
+
+      const [rows] = await connection.query(query);
+      const data = rows as Record<string, unknown>[];
+
+      // Determine file path
+      const targetPath = filePath
+        ? expandTilde(filePath)
+        : getDefaultFilePath(table, format);
+
+      ensureDirectoryExists(targetPath);
+
+      // Export data
+      let content: string;
+      if (format === 'json') {
+        content = JSON.stringify(data, null, 2);
+      } else {
+        // CSV format
+        if (data.length === 0) {
+          content = '';
+        } else {
+          const headers = Object.keys(data[0]);
+          const csvRows = [
+            headers.join(','),
+            ...data.map((row) =>
+              headers.map((h) => {
+                const val = row[h];
+                if (val === null) return '';
+                if (typeof val === 'string') return '"' + val.replace(/"/g, '""') + '"';
+                return String(val);
+              }).join(',')
+            ),
+          ];
+          content = csvRows.join('\n');
+        }
+      }
+
+      fs.writeFileSync(targetPath, content, 'utf-8');
+      const stats = fs.statSync(targetPath);
+
+      return {
+        success: true,
+        filePath: targetPath,
+        rowCount: data.length,
+        fileSize: formatFileSize(stats.size),
+      };
+    } finally {
+      connection.release();
+    }
+  }
+
+  async createTable(table: string, columns: TableColumnDef[], database?: string): Promise<CreateTableResult> {
+    if (!this.pool) throw new Error('Not connected');
+
+    const connection = await this.pool.getConnection();
+
+    try {
+      if (database && database !== this.config.database) {
+        await connection.query(`USE ${mysql.escapeId(database)}`);
+      }
+
+      const columnDefs = columns.map((col) => {
+        let def = `${mysql.escapeId(col.name)} ${col.type}`;
+        if (col.nullable === false) def += ' NOT NULL';
+        if (col.primaryKey) def += ' PRIMARY KEY';
+        if (col.defaultValue !== undefined) {
+          def += ` DEFAULT ${this.escapeValue(col.defaultValue)}`;
+        }
+        return def;
+      });
+
+      const query = `CREATE TABLE ${mysql.escapeId(table)} (${columnDefs.join(', ')})`;
+      await connection.query(query);
+
+      return { success: true, tableName: table };
+    } finally {
+      connection.release();
+    }
+  }
+
+  async dropTable(table: string, ifExists = false, database?: string): Promise<DropTableResult> {
+    if (!this.pool) throw new Error('Not connected');
+
+    const connection = await this.pool.getConnection();
+
+    try {
+      if (database && database !== this.config.database) {
+        await connection.query(`USE ${mysql.escapeId(database)}`);
+      }
+
+      const query = ifExists
+        ? `DROP TABLE IF EXISTS ${mysql.escapeId(table)}`
+        : `DROP TABLE ${mysql.escapeId(table)}`;
+
+      await connection.query(query);
+
+      return { success: true, tableName: table };
+    } finally {
+      connection.release();
+    }
+  }
+
+  async getTableStats(table: string, database?: string): Promise<TableStatsResult> {
+    if (!this.pool) throw new Error('Not connected');
+
+    const connection = await this.pool.getConnection();
+
+    try {
+      const dbName = database || this.config.database;
+      if (!dbName) throw new Error('Database name required');
+
+      if (database && database !== this.config.database) {
+        await connection.query(`USE ${mysql.escapeId(database)}`);
+      }
+
+      // Get row count
+      const [countResult] = await connection.query(
+        `SELECT COUNT(*) as count FROM ${mysql.escapeId(table)}`
+      );
+      const rowCount = (countResult as any)[0].count;
+
+      // Get column count
+      const [colResult] = await connection.query(
+        `SELECT COUNT(*) as count FROM INFORMATION_SCHEMA.COLUMNS WHERE TABLE_SCHEMA = ? AND TABLE_NAME = ?`,
+        [dbName, table]
+      );
+      const columns = (colResult as any)[0].count;
+
+      // Get indexes
+      const [indexResult] = await connection.query(
+        `SELECT INDEX_NAME FROM INFORMATION_SCHEMA.STATISTICS WHERE TABLE_SCHEMA = ? AND TABLE_NAME = ? AND INDEX_NAME != 'PRIMARY' GROUP BY INDEX_NAME`,
+        [dbName, table]
+      );
+      const indexes = (indexResult as any[]).map((row) => row.INDEX_NAME);
+
+      // Get table size
+      const [sizeResult] = await connection.query(
+        `SELECT ROUND((DATA_LENGTH + INDEX_LENGTH) / 1024 / 1024, 2) as size_mb FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_SCHEMA = ? AND TABLE_NAME = ?`,
+        [dbName, table]
+      );
+      const sizeMb = (sizeResult as any)[0]?.size_mb || 0;
+      const size = sizeMb > 0 ? `${sizeMb} MB` : '< 0.01 MB';
+
+      return {
+        tableName: table,
+        rowCount,
+        columns,
+        indexes,
+        size,
+      };
+    } finally {
+      connection.release();
+    }
+  }
+
+  async previewData(
+    table: string,
+    page = 1,
+    pageSize = 50,
+    orderBy?: string,
+    database?: string
+  ): Promise<PreviewDataResult> {
+    if (!this.pool) throw new Error('Not connected');
+
+    const connection = await this.pool.getConnection();
+
+    try {
+      if (database && database !== this.config.database) {
+        await connection.query(`USE ${mysql.escapeId(database)}`);
+      }
+
+      // Get total row count
+      const [countResult] = await connection.query(
+        `SELECT COUNT(*) as count FROM ${mysql.escapeId(table)}`
+      );
+      const totalRows = (countResult as any)[0].count;
+
+      const totalPages = Math.ceil(totalRows / pageSize);
+      const offset = (page - 1) * pageSize;
+
+      // Build query
+      let query = `SELECT * FROM ${mysql.escapeId(table)}`;
+      if (orderBy) {
+        query += ` ORDER BY ${mysql.escapeId(orderBy)}`;
+      }
+      query += ` LIMIT ${pageSize} OFFSET ${offset}`;
+
+      const [rows] = await connection.query(query);
+
+      return {
+        rows: rows as Record<string, unknown>[],
+        currentPage: page,
+        totalPages,
+        totalRows,
+      };
+    } finally {
+      connection.release();
+    }
+  }
+
+  async sampleData(table: string, count = 10, database?: string): Promise<SampleDataResult> {
+    if (!this.pool) throw new Error('Not connected');
+
+    const connection = await this.pool.getConnection();
+
+    try {
+      if (database && database !== this.config.database) {
+        await connection.query(`USE ${mysql.escapeId(database)}`);
+      }
+
+      const [rows] = await connection.query(
+        `SELECT * FROM ${mysql.escapeId(table)} ORDER BY RAND() LIMIT ${count}`
+      );
+
+      return {
+        rows: rows as Record<string, unknown>[],
+        sampleCount: (rows as any[]).length,
+      };
+    } finally {
+      connection.release();
+    }
+  }
 }