@hyqf98/easy_db_mcp_server 1.0.0 → 2.0.0

package/src/database/sqlite.ts

@@ -1,11 +1,25 @@
 import Database from 'better-sqlite3';
+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 SQLiteAdapter implements DatabaseAdapter {
   private db?: Database.Database;
@@ -90,4 +104,272 @@ export class SQLiteAdapter implements DatabaseAdapter {
       this.db = undefined;
     }
   }
+
+  async executeTransaction(queries: string[]): Promise<TransactionResult> {
+    if (!this.db) throw new Error('Not connected');
+
+    const results: unknown[] = [];
+    let totalAffectedRows = 0;
+
+    this.db.exec('BEGIN TRANSACTION');
+
+    try {
+      for (const query of queries) {
+        const trimmed = query.trim().toUpperCase();
+
+        if (trimmed.startsWith('SELECT')) {
+          const rows = this.db.prepare(query).all() as Record<string, unknown>[];
+          results.push({ rows, rowCount: rows.length });
+        } else {
+          const result = this.db.prepare(query).run();
+          totalAffectedRows += result.changes;
+          results.push({ affectedRows: result.changes });
+        }
+      }
+
+      this.db.exec('COMMIT');
+
+      return {
+        success: true,
+        affectedRows: totalAffectedRows,
+        results,
+      };
+    } catch (error) {
+      this.db.exec('ROLLBACK');
+      throw error;
+    }
+  }
+
+  async batchInsert(
+    table: string,
+    data: Record<string, unknown>[]
+  ): Promise<BatchInsertResult> {
+    if (!this.db) throw new Error('Not connected');
+
+    if (data.length === 0) {
+      return { insertedRows: 0, duplicateRows: 0 };
+    }
+
+    const columns = Object.keys(data[0]);
+    const columnList = columns.join(', ');
+    const placeholders = columns.map(() => '?').join(', ');
+
+    const query = `INSERT INTO ${table} (${columnList}) VALUES (${placeholders})`;
+    const stmt = this.db.prepare(query);
+
+    let insertedRows = 0;
+    let duplicateRows = 0;
+
+    this.db.exec('BEGIN TRANSACTION');
+
+    try {
+      for (const row of data) {
+        try {
+          const values = columns.map((col) => row[col]);
+          stmt.run(values);
+          insertedRows++;
+        } catch (error: any) {
+          if (error.code === 'SQLITE_CONSTRAINT') {
+            duplicateRows++;
+          } else {
+            throw error;
+          }
+        }
+      }
+
+      this.db.exec('COMMIT');
+
+      return { insertedRows, duplicateRows };
+    } catch (error) {
+      this.db.exec('ROLLBACK');
+      throw error;
+    }
+  }
+
+  async batchUpdate(
+    table: string,
+    updates: BatchUpdateOptions
+  ): Promise<BatchUpdateResult> {
+    if (!this.db) throw new Error('Not connected');
+
+    const setClause = Object.entries(updates.set)
+      .map(([key, value]) => `${key} = ${this.escapeValue(value)}`)
+      .join(', ');
+
+    const query = `UPDATE ${table} SET ${setClause} WHERE ${updates.where}`;
+    const result = this.db.prepare(query).run();
+
+    return { affectedRows: result.changes };
+  }
+
+  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 `'${String(value).replace(/'/g, "''")}'`;
+  }
+
+  async exportData(
+    table: string,
+    format: 'json' | 'csv',
+    filePath?: string,
+    options?: ExportOptions
+  ): Promise<ExportResult> {
+    if (!this.db) throw new Error('Not connected');
+
+    let query = `SELECT * FROM ${table}`;
+    if (options?.where) {
+      query += ` WHERE ${options.where}`;
+    }
+    if (options?.limit) {
+      query += ` LIMIT ${options.limit}`;
+    }
+
+    const data = this.db.prepare(query).all() as Record<string, unknown>[];
+
+    const targetPath = filePath
+      ? expandTilde(filePath)
+      : getDefaultFilePath(table, format);
+
+    ensureDirectoryExists(targetPath);
+
+    let content: string;
+    if (format === 'json') {
+      content = JSON.stringify(data, null, 2);
+    } else {
+      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),
+    };
+  }
+
+  async createTable(table: string, columns: TableColumnDef[]): Promise<CreateTableResult> {
+    if (!this.db) throw new Error('Not connected');
+
+    const columnDefs = columns.map((col) => {
+      let def = `${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 ${table} (${columnDefs.join(', ')})`;
+    this.db.exec(query);
+
+    return { success: true, tableName: table };
+  }
+
+  async dropTable(table: string, ifExists = false): Promise<DropTableResult> {
+    if (!this.db) throw new Error('Not connected');
+
+    const query = ifExists
+      ? `DROP TABLE IF EXISTS ${table}`
+      : `DROP TABLE ${table}`;
+
+    this.db.exec(query);
+
+    return { success: true, tableName: table };
+  }
+
+  async getTableStats(table: string): Promise<TableStatsResult> {
+    if (!this.db) throw new Error('Not connected');
+
+    // Get row count
+    const countResult = this.db.prepare(`SELECT COUNT(*) as count FROM ${table}`).get() as any;
+    const rowCount = countResult.count;
+
+    // Get column count
+    const colResult = this.db.prepare(`PRAGMA table_info(${table})`).all();
+    const columns = colResult.length;
+
+    // Get indexes
+    const indexResult = this.db.prepare(`PRAGMA index_list(${table})`).all() as any[];
+    const indexes = indexResult.map((row) => row.name);
+
+    // Get table size (SQLite doesn't have a direct way, estimate from page count)
+    const pragmaResult = this.db.prepare(`PRAGMA page_count`).get() as any;
+    const pageSizeResult = this.db.prepare(`PRAGMA page_size`).get() as any;
+    const sizeBytes = pragmaResult.page_count * pageSizeResult.page_size;
+    const size = formatFileSize(sizeBytes);
+
+    return {
+      tableName: table,
+      rowCount,
+      columns,
+      indexes,
+      size,
+    };
+  }
+
+  async previewData(
+    table: string,
+    page = 1,
+    pageSize = 50,
+    orderBy?: string
+  ): Promise<PreviewDataResult> {
+    if (!this.db) throw new Error('Not connected');
+
+    // Get total row count
+    const countResult = this.db.prepare(`SELECT COUNT(*) as count FROM ${table}`).get() as any;
+    const totalRows = countResult.count;
+
+    const totalPages = Math.ceil(totalRows / pageSize);
+    const offset = (page - 1) * pageSize;
+
+    // Build query
+    let query = `SELECT * FROM ${table}`;
+    if (orderBy) {
+      query += ` ORDER BY ${orderBy}`;
+    }
+    query += ` LIMIT ${pageSize} OFFSET ${offset}`;
+
+    const rows = this.db.prepare(query).all() as Record<string, unknown>[];
+
+    return {
+      rows,
+      currentPage: page,
+      totalPages,
+      totalRows,
+    };
+  }
+
+  async sampleData(table: string, count = 10): Promise<SampleDataResult> {
+    if (!this.db) throw new Error('Not connected');
+
+    const rows = this.db
+      .prepare(`SELECT * FROM ${table} ORDER BY RANDOM() LIMIT ${count}`)
+      .all() as Record<string, unknown>[];
+
+    return {
+      rows,
+      sampleCount: rows.length,
+    };
+  }
 }