@hyqf98/easy_db_mcp_server 1.0.0 → 2.0.0

package/dist/database/mysql.js

@@ -1,4 +1,6 @@
 import mysql from 'mysql2/promise';
+import fs from 'fs';
+import { expandTilde, formatFileSize, ensureDirectoryExists, getDefaultFilePath } from '../utils/file.js';
 export class MySQLAdapter {
     pool;
     config;
@@ -59,33 +61,51 @@ export class MySQLAdapter {
     async executeQuery(sql, database) {
         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);
-        return {
-            rows: rows,
-            rowCount: Array.isArray(rows) ? rows.length : 0,
-        };
+        // 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)}`);
+            }
+            const [rows] = await connection.query(sql);
+            return {
+                rows: rows,
+                rowCount: Array.isArray(rows) ? rows.length : 0,
+            };
+        }
+        finally {
+            connection.release();
+        }
     }
     async executeSQL(sql, database) {
         if (!this.pool)
             throw new Error('Not connected');
-        // Allow SQL execution with database-specific queries
-        const [result] = await this.pool.query(sql);
-        // @ts-ignore - MySQL result structure
-        if (result.affectedRows !== undefined) {
-            // @ts-ignore
-            return { affectedRows: result.affectedRows };
+        // 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)}`);
+            }
+            const [result] = await connection.query(sql);
+            // @ts-ignore - MySQL result structure
+            if (result.affectedRows !== undefined) {
+                // @ts-ignore
+                return { affectedRows: result.affectedRows };
+            }
+            return {
+                rows: result,
+                rowCount: Array.isArray(result) ? result.length : 0,
+            };
+        }
+        finally {
+            connection.release();
         }
-        return {
-            rows: result,
-            rowCount: Array.isArray(result) ? result.length : 0,
-        };
     }
     async close() {
         if (this.pool) {
@@ -93,4 +113,302 @@ export class MySQLAdapter {
             this.pool = undefined;
         }
     }
+    async executeTransaction(queries, database) {
+        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 = [];
+            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, data, database) {
+        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) {
+                    // Check for duplicate key error
+                    if (error.code === 'ER_DUP_ENTRY') {
+                        duplicateRows++;
+                    }
+                    else {
+                        throw error;
+                    }
+                }
+            }
+            return { insertedRows, duplicateRows };
+        }
+        finally {
+            connection.release();
+        }
+    }
+    async batchUpdate(table, updates, database) {
+        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();
+        }
+    }
+    escapeValue(value) {
+        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, format, filePath, options, database) {
+        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;
+            // Determine file path
+            const targetPath = filePath
+                ? expandTilde(filePath)
+                : getDefaultFilePath(table, format);
+            ensureDirectoryExists(targetPath);
+            // Export data
+            let content;
+            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, columns, database) {
+        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, ifExists = false, database) {
+        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, database) {
+        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[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[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.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[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, page = 1, pageSize = 50, orderBy, database) {
+        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[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,
+                currentPage: page,
+                totalPages,
+                totalRows,
+            };
+        }
+        finally {
+            connection.release();
+        }
+    }
+    async sampleData(table, count = 10, database) {
+        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,
+                sampleCount: rows.length,
+            };
+        }
+        finally {
+            connection.release();
+        }
+    }
 }

package/dist/database/postgresql.d.ts

@@ -1,4 +1,4 @@
-import type { DatabaseAdapter, TableInfo, TableColumn, QueryResult } from './base.js';
+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';
 export declare class PostgreSQLAdapter implements DatabaseAdapter {
     private pool?;
@@ -12,4 +12,14 @@ export declare class PostgreSQLAdapter implements DatabaseAdapter {
         affectedRows: number;
     }>;
     close(): Promise<void>;
+    executeTransaction(queries: string[], database?: string): Promise<TransactionResult>;
+    batchInsert(table: string, data: Record<string, unknown>[], database?: string): Promise<BatchInsertResult>;
+    batchUpdate(table: string, updates: BatchUpdateOptions, database?: string): Promise<BatchUpdateResult>;
+    private escapeValue;
+    exportData(table: string, format: 'json' | 'csv', filePath?: string, options?: ExportOptions, database?: string): Promise<ExportResult>;
+    createTable(table: string, columns: TableColumnDef[], database?: string): Promise<CreateTableResult>;
+    dropTable(table: string, ifExists?: boolean, database?: string): Promise<DropTableResult>;
+    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>;
 }