@libredb/studio 0.9.7 → 0.9.13

package/src/lib/db/providers/document/mongodb.ts

@@ -1,992 +0,0 @@
-/**
- * MongoDB Database Provider
- * Document database support using official MongoDB driver
- */
-
-import { MongoClient, ObjectId, Binary, Decimal128, type Db, type Document, type MongoClientOptions } from 'mongodb';
-import { BaseDatabaseProvider } from '../../base-provider';
-import {
-  type DatabaseConnection,
-  type TableSchema,
-  type ColumnSchema,
-  type QueryResult,
-  type HealthInfo,
-  type MaintenanceType,
-  type MaintenanceResult,
-  type ProviderOptions,
-  type ProviderCapabilities,
-  type ProviderLabels,
-  type PreparedQuery,
-  type QueryPrepareOptions,
-  type SlowQuery,
-  type ActiveSession,
-  type DatabaseOverview,
-  type PerformanceMetrics,
-  type SlowQueryStats,
-  type ActiveSessionDetails,
-  type TableStats,
-  type IndexStats,
-  type StorageStats,
-} from '../../types';
-import {
-  DatabaseConfigError,
-  ConnectionError,
-  QueryError,
-  mapDatabaseError,
-} from '../../errors';
-import { formatBytes } from '../../utils/pool-manager';
-
-// ============================================================================
-// Types
-// ============================================================================
-
-interface MongoQuery {
-  collection: string;
-  operation: 'find' | 'findOne' | 'aggregate' | 'count' | 'distinct' | 'insertOne' | 'insertMany' | 'updateOne' | 'updateMany' | 'deleteOne' | 'deleteMany';
-  filter?: Document;
-  pipeline?: Document[];
-  update?: Document;
-  documents?: Document[];
-  options?: {
-    limit?: number;
-    skip?: number;
-    sort?: Document;
-    projection?: Document;
-  };
-}
-
-// ============================================================================
-// MongoDB Provider
-// ============================================================================
-
-export class MongoDBProvider extends BaseDatabaseProvider {
-  private client: MongoClient | null = null;
-  private db: Db | null = null;
-
-  constructor(config: DatabaseConnection, options: ProviderOptions = {}) {
-    super(config, options);
-    this.validate();
-  }
-
-  // ============================================================================
-  // Provider Metadata
-  // ============================================================================
-
-  public override getCapabilities(): ProviderCapabilities {
-    return {
-      queryLanguage: 'json',
-      supportsExplain: false,
-      supportsExternalQueryLimiting: false,
-      supportsCreateTable: false,
-      supportsMaintenance: true,
-      maintenanceOperations: ['vacuum', 'analyze', 'check'],
-      supportsConnectionString: true,
-      defaultPort: 27017,
-      schemaRefreshPattern: '"operation"\\s*:\\s*"(insert|delete|update)',
-    };
-  }
-
-  public override getLabels(): ProviderLabels {
-    return {
-      entityName: 'Collection',
-      entityNamePlural: 'Collections',
-      rowName: 'document',
-      rowNamePlural: 'documents',
-      selectAction: 'Find Documents',
-      generateAction: 'Generate Find',
-      analyzeAction: 'Validate Collection',
-      vacuumAction: 'Compact Collection',
-      searchPlaceholder: 'Search collections or fields...',
-      analyzeGlobalLabel: 'Run Validate',
-      analyzeGlobalTitle: 'Validate Collections',
-      analyzeGlobalDesc: 'Checks collection structure and indexes integrity for all collections.',
-      vacuumGlobalLabel: 'Run Compact',
-      vacuumGlobalTitle: 'Compact Storage',
-      vacuumGlobalDesc: 'Defragments and compacts collection storage to reclaim disk space.',
-    };
-  }
-
-  public override prepareQuery(query: string, options: QueryPrepareOptions = {}): PreparedQuery {
-    return { query, wasLimited: false, limit: options.limit || 100, offset: 0 };
-  }
-
-  // ============================================================================
-  // Validation
-  // ============================================================================
-
-  public validate(): void {
-    super.validate();
-
-    if (!this.config.connectionString) {
-      if (!this.config.host) {
-        throw new DatabaseConfigError('Host or connection string is required for MongoDB', 'mongodb');
-      }
-      if (!this.config.database) {
-        throw new DatabaseConfigError('Database name is required for MongoDB', 'mongodb');
-      }
-    }
-  }
-
-  // ============================================================================
-  // Connection Management
-  // ============================================================================
-
-  public async connect(): Promise<void> {
-    if (this.client && this.db) {
-      return;
-    }
-
-    try {
-      const connectionString = this.buildConnectionString();
-      const options: MongoClientOptions = {
-        maxPoolSize: this.poolConfig.max,
-        minPoolSize: this.poolConfig.min,
-        maxIdleTimeMS: this.poolConfig.idleTimeout,
-        connectTimeoutMS: this.poolConfig.acquireTimeout,
-        serverSelectionTimeoutMS: this.poolConfig.acquireTimeout,
-      };
-
-      this.client = new MongoClient(connectionString, options);
-      await this.client.connect();
-
-      // Get database name from connection string or config
-      const dbName = this.getDatabaseName();
-      this.db = this.client.db(dbName);
-
-      // Test connection
-      await this.db.command({ ping: 1 });
-
-      this.setConnected(true);
-    } catch (error) {
-      this.setError(error instanceof Error ? error : new Error(String(error)));
-      throw new ConnectionError(
-        `Failed to connect to MongoDB: ${error instanceof Error ? error.message : error}`,
-        'mongodb',
-        this.config.host,
-        this.config.port
-      );
-    }
-  }
-
-  public async disconnect(): Promise<void> {
-    if (this.client) {
-      try {
-        await this.client.close();
-      } finally {
-        this.client = null;
-        this.db = null;
-        this.setConnected(false);
-      }
-    }
-  }
-
-  private buildConnectionString(): string {
-    if (this.config.connectionString) {
-      return this.config.connectionString;
-    }
-
-    const auth = this.config.user && this.config.password
-      ? `${encodeURIComponent(this.config.user)}:${encodeURIComponent(this.config.password)}@`
-      : '';
-
-    const host = this.config.host || 'localhost';
-    const port = this.config.port || 27017;
-    const database = this.config.database || 'test';
-
-    return `mongodb://${auth}${host}:${port}/${database}`;
-  }
-
-  private getDatabaseName(): string {
-    if (this.config.database) {
-      return this.config.database;
-    }
-
-    // Extract from connection string
-    if (this.config.connectionString) {
-      const match = this.config.connectionString.match(/\/([^/?]+)(\?|$)/);
-      if (match) {
-        return match[1];
-      }
-    }
-
-    return 'test';
-  }
-
-  // ============================================================================
-  // Query Execution
-  // ============================================================================
-
-  /**
-   * Execute a MongoDB query
-   * Accepts JSON-formatted MQL queries
-   *
-   * @example
-   * // Find documents
-   * {"collection": "users", "operation": "find", "filter": {"age": {"$gt": 18}}, "options": {"limit": 10}}
-   *
-   * // Aggregate
-   * {"collection": "orders", "operation": "aggregate", "pipeline": [{"$group": {"_id": "$status", "count": {"$sum": 1}}}]}
-   *
-   * // Insert
-   * {"collection": "users", "operation": "insertOne", "documents": [{"name": "John", "email": "john@example.com"}]}
-   */
-  public async query(queryStr: string): Promise<QueryResult> {
-    this.ensureConnected();
-
-    return this.trackQuery(async () => {
-      const { result, executionTime } = await this.measureExecution(async () => {
-        try {
-          const query = this.parseQuery(queryStr);
-          const collection = this.db!.collection(query.collection);
-
-          let rows: Document[] = [];
-          let affectedCount = 0;
-
-          switch (query.operation) {
-            case 'find': {
-              const cursor = collection.find(query.filter || {});
-              if (query.options?.projection) cursor.project(query.options.projection);
-              if (query.options?.sort) cursor.sort(query.options.sort);
-              if (query.options?.skip) cursor.skip(query.options.skip);
-              if (query.options?.limit) cursor.limit(query.options.limit);
-              else cursor.limit(100); // Default limit
-              try {
-                rows = await cursor.toArray();
-              } finally {
-                await cursor.close();
-              }
-              break;
-            }
-
-            case 'findOne': {
-              const doc = await collection.findOne(query.filter || {}, {
-                projection: query.options?.projection,
-              });
-              rows = doc ? [doc] : [];
-              break;
-            }
-
-            case 'aggregate':
-              rows = await collection.aggregate(query.pipeline || []).toArray();
-              break;
-
-            case 'count':
-              const count = await collection.countDocuments(query.filter || {});
-              rows = [{ count }];
-              break;
-
-            case 'distinct':
-              const field = query.options?.projection ? Object.keys(query.options.projection)[0] : '_id';
-              const values = await collection.distinct(field, query.filter || {});
-              rows = values.map(v => ({ [field]: v }));
-              break;
-
-            case 'insertOne':
-              if (!query.documents || query.documents.length === 0) {
-                throw new QueryError('Document is required for insertOne', 'mongodb');
-              }
-              const insertOneResult = await collection.insertOne(query.documents[0]);
-              rows = [{ insertedId: insertOneResult.insertedId, acknowledged: insertOneResult.acknowledged }];
-              affectedCount = insertOneResult.acknowledged ? 1 : 0;
-              break;
-
-            case 'insertMany':
-              if (!query.documents || query.documents.length === 0) {
-                throw new QueryError('Documents are required for insertMany', 'mongodb');
-              }
-              const insertManyResult = await collection.insertMany(query.documents);
-              rows = [{ insertedCount: insertManyResult.insertedCount, insertedIds: insertManyResult.insertedIds }];
-              affectedCount = insertManyResult.insertedCount;
-              break;
-
-            case 'updateOne':
-              if (!query.update) {
-                throw new QueryError('Update document is required for updateOne', 'mongodb');
-              }
-              const updateOneResult = await collection.updateOne(query.filter || {}, query.update);
-              rows = [{ matchedCount: updateOneResult.matchedCount, modifiedCount: updateOneResult.modifiedCount }];
-              affectedCount = updateOneResult.modifiedCount;
-              break;
-
-            case 'updateMany':
-              if (!query.update) {
-                throw new QueryError('Update document is required for updateMany', 'mongodb');
-              }
-              const updateManyResult = await collection.updateMany(query.filter || {}, query.update);
-              rows = [{ matchedCount: updateManyResult.matchedCount, modifiedCount: updateManyResult.modifiedCount }];
-              affectedCount = updateManyResult.modifiedCount;
-              break;
-
-            case 'deleteOne':
-              const deleteOneResult = await collection.deleteOne(query.filter || {});
-              rows = [{ deletedCount: deleteOneResult.deletedCount }];
-              affectedCount = deleteOneResult.deletedCount;
-              break;
-
-            case 'deleteMany':
-              const deleteManyResult = await collection.deleteMany(query.filter || {});
-              rows = [{ deletedCount: deleteManyResult.deletedCount }];
-              affectedCount = deleteManyResult.deletedCount;
-              break;
-
-            default:
-              throw new QueryError(`Unsupported operation: ${query.operation}`, 'mongodb');
-          }
-
-          // Convert ObjectId to string for display
-          const serializedRows = rows.map(row => this.serializeDocument(row));
-
-          return {
-            rows: serializedRows,
-            fields: serializedRows.length > 0 ? Object.keys(serializedRows[0]) : [],
-            affectedCount,
-          };
-        } catch (error) {
-          if (error instanceof QueryError) throw error;
-          throw mapDatabaseError(error, 'mongodb', queryStr);
-        }
-      });
-
-      return {
-        rows: result.rows,
-        fields: result.fields,
-        rowCount: result.rows.length || result.affectedCount,
-        executionTime,
-      };
-    });
-  }
-
-  private parseQuery(queryStr: string): MongoQuery {
-    try {
-      // Try to parse as JSON
-      const parsed = JSON.parse(queryStr.trim());
-
-      if (!parsed.collection) {
-        throw new QueryError('Collection name is required in query', 'mongodb');
-      }
-      if (!parsed.operation) {
-        throw new QueryError('Operation is required in query (find, findOne, aggregate, etc.)', 'mongodb');
-      }
-
-      return parsed as MongoQuery;
-    } catch (error) {
-      if (error instanceof QueryError) throw error;
-      throw new QueryError(
-        `Invalid MongoDB query format. Expected JSON with "collection" and "operation" fields. Example: {"collection": "users", "operation": "find", "filter": {}}`,
-        'mongodb'
-      );
-    }
-  }
-
-  private serializeDocument(doc: Document): Record<string, unknown> {
-    const serialized: Record<string, unknown> = {};
-
-    for (const [key, value] of Object.entries(doc)) {
-      if (value === null || value === undefined) {
-        serialized[key] = value;
-      } else if (typeof value === 'object') {
-        if (value instanceof ObjectId) {
-          serialized[key] = value.toString();
-        } else if (value instanceof Binary) {
-          serialized[key] = `<Binary: ${value.length()} bytes>`;
-        } else if (value instanceof Decimal128) {
-          serialized[key] = value.toString();
-        } else if (value instanceof Date) {
-          serialized[key] = value.toISOString();
-        } else if (Array.isArray(value)) {
-          serialized[key] = value.map(v =>
-            typeof v === 'object' && v !== null ? this.serializeDocument(v) : v
-          );
-        } else {
-          serialized[key] = this.serializeDocument(value as Document);
-        }
-      } else {
-        serialized[key] = value;
-      }
-    }
-
-    return serialized;
-  }
-
-  // ============================================================================
-  // Schema Operations
-  // ============================================================================
-
-  /**
-   * Get schema by listing collections and sampling documents to infer field types
-   */
-  public async getSchema(): Promise<TableSchema[]> {
-    this.ensureConnected();
-
-    const allCollections = await this.db!.listCollections().toArray();
-    // Skip system collections and limit to 200 collections for performance
-    const collections = allCollections
-      .filter(c => !c.name.startsWith('system.'))
-      .slice(0, 200);
-    const schemas: TableSchema[] = [];
-
-    for (const collInfo of collections) {
-      const collName = collInfo.name;
-      const collection = this.db!.collection(collName);
-
-      // Get document count
-      const rowCount = await collection.estimatedDocumentCount();
-
-      // Get collection stats for size
-      let sizeBytes = 0;
-      try {
-        const stats = await this.db!.command({ collStats: collName });
-        sizeBytes = stats.size || 0;
-      } catch {
-        // Stats might not be available
-      }
-
-      // Sample documents to infer schema
-      const sampleDocs = await collection.find({}).limit(100).toArray();
-      const columns = this.inferSchemaFromDocuments(sampleDocs);
-
-      // Get indexes
-      const indexList = await collection.indexes();
-      const indexes = indexList.map(idx => ({
-        name: idx.name || 'unknown',
-        columns: Object.keys(idx.key || {}),
-        unique: idx.unique || false,
-      }));
-
-      schemas.push({
-        name: collName,
-        rowCount,
-        size: formatBytes(sizeBytes),
-        columns,
-        indexes,
-        foreignKeys: [], // MongoDB doesn't have foreign keys
-      });
-    }
-
-    return schemas;
-  }
-
-  private inferSchemaFromDocuments(docs: Document[]): ColumnSchema[] {
-    const fieldTypes = new Map<string, Set<string>>();
-
-    for (const doc of docs) {
-      this.extractFieldTypes(doc, '', fieldTypes);
-    }
-
-    const columns: ColumnSchema[] = [];
-
-    for (const [fieldName, types] of fieldTypes) {
-      const typeArray = Array.from(types);
-      const type = typeArray.length === 1 ? typeArray[0] : `mixed(${typeArray.join('|')})`;
-
-      columns.push({
-        name: fieldName,
-        type,
-        nullable: types.has('null') || types.has('undefined'),
-        isPrimary: fieldName === '_id',
-        defaultValue: undefined,
-      });
-    }
-
-    // Sort: _id first, then alphabetically
-    columns.sort((a, b) => {
-      if (a.name === '_id') return -1;
-      if (b.name === '_id') return 1;
-      return a.name.localeCompare(b.name);
-    });
-
-    return columns;
-  }
-
-  private extractFieldTypes(doc: Document, prefix: string, fieldTypes: Map<string, Set<string>>): void {
-    for (const [key, value] of Object.entries(doc)) {
-      const fieldName = prefix ? `${prefix}.${key}` : key;
-
-      if (!fieldTypes.has(fieldName)) {
-        fieldTypes.set(fieldName, new Set());
-      }
-
-      const type = this.getMongoType(value);
-      fieldTypes.get(fieldName)!.add(type);
-
-      // Don't recurse into nested objects for now (keep it flat)
-      // Uncomment below to include nested fields
-      // if (type === 'object' && value !== null && !Array.isArray(value)) {
-      //   this.extractFieldTypes(value as Document, fieldName, fieldTypes);
-      // }
-    }
-  }
-
-  private getMongoType(value: unknown): string {
-    if (value === null) return 'null';
-    if (value === undefined) return 'undefined';
-    if (Array.isArray(value)) return 'array';
-    if (value instanceof Date) return 'date';
-    if (value instanceof ObjectId) return 'objectId';
-    if (value instanceof Binary) return 'binary';
-    if (value instanceof Decimal128) return 'decimal';
-    if (typeof value === 'object') return 'object';
-    return typeof value;
-  }
-
-  // ============================================================================
-  // Health & Monitoring
-  // ============================================================================
-
-  public async getHealth(): Promise<HealthInfo> {
-    this.ensureConnected();
-
-    try {
-      const serverStatus = await this.db!.admin().serverStatus();
-      const dbStats = await this.db!.stats();
-
-      // Get current operations
-      const currentOps = await this.db!.admin().command({ currentOp: 1 });
-
-      const activeSessions: ActiveSession[] = (currentOps.inprog || [])
-        .slice(0, 10)
-        .map((op: Record<string, unknown>) => ({
-          pid: op.opid || 'N/A',
-          user: op.client || 'N/A',
-          database: op.ns || this.getDatabaseName(),
-          state: op.active ? 'active' : 'idle',
-          query: JSON.stringify(op.command || {}).substring(0, 100),
-          duration: (typeof op.microsecs_running === 'number' && op.microsecs_running > 0)
-            ? `${(op.microsecs_running / 1000000).toFixed(2)}s`
-            : 'N/A',
-        }));
-
-      const slowQueries: SlowQuery[] = [];
-
-      // Try to get slow query info from profiler
-      try {
-        const profilerDocs = await this.db!.collection('system.profile')
-          .find({})
-          .sort({ ts: -1 })
-          .limit(5)
-          .toArray();
-
-        for (const doc of profilerDocs) {
-          slowQueries.push({
-            query: JSON.stringify(doc.command || doc.query || {}).substring(0, 100),
-            calls: 1,
-            avgTime: `${doc.millis || 0}ms`,
-          });
-        }
-      } catch {
-        slowQueries.push({
-          query: 'Profiler not enabled. Run db.setProfilingLevel(1) to enable.',
-          calls: 0,
-          avgTime: 'N/A',
-        });
-      }
-
-      return {
-        activeConnections: serverStatus.connections?.current || 0,
-        databaseSize: formatBytes(dbStats.dataSize || 0),
-        cacheHitRatio: serverStatus.wiredTiger?.cache
-          ? `${((1 - (serverStatus.wiredTiger.cache['pages read into cache'] || 0) /
-              Math.max(1, serverStatus.wiredTiger.cache['pages requested from the cache'] || 1)) * 100).toFixed(1)}%`
-          : 'N/A',
-        slowQueries,
-        activeSessions,
-      };
-    } catch (error) {
-      this.logError('getHealth', error);
-      return {
-        activeConnections: 0,
-        databaseSize: 'N/A',
-        cacheHitRatio: 'N/A',
-        slowQueries: [{ query: 'Error fetching health info', calls: 0, avgTime: 'N/A' }],
-        activeSessions: [],
-      };
-    }
-  }
-
-  // ============================================================================
-  // Maintenance Operations
-  // ============================================================================
-
-  public async runMaintenance(
-    type: MaintenanceType,
-    target?: string
-  ): Promise<MaintenanceResult> {
-    this.ensureConnected();
-
-    const { result, executionTime } = await this.measureExecution(async () => {
-      try {
-        switch (type) {
-          case 'analyze':
-            // Validate collection
-            if (target) {
-              await this.db!.command({ validate: target });
-              return { success: true, message: `Validated collection: ${target}` };
-            } else {
-              const collections = await this.db!.listCollections().toArray();
-              for (const coll of collections) {
-                await this.db!.command({ validate: coll.name });
-              }
-              return { success: true, message: `Validated ${collections.length} collections` };
-            }
-
-          case 'reindex':
-            // reIndex was removed in MongoDB 6.0+
-            return {
-              success: false,
-              message: 'Reindex is not supported in MongoDB 6.0+. Use compact instead to defragment collections.',
-            };
-
-          case 'vacuum':
-          case 'optimize':
-            // Compact collection (similar to vacuum)
-            if (target) {
-              await this.db!.command({ compact: target });
-              return { success: true, message: `Compacted collection: ${target}` };
-            } else {
-              const collections = await this.db!.listCollections().toArray();
-              for (const coll of collections) {
-                try {
-                  await this.db!.command({ compact: coll.name });
-                } catch {
-                  // Some collections might not be compactable
-                }
-              }
-              return { success: true, message: `Compacted collections` };
-            }
-
-          case 'check': {
-            // Run dbCheck — requires a collection name as target
-            if (!target) {
-              throw new QueryError('Collection name is required for dbCheck operation', 'mongodb');
-            }
-            const checkResult = await this.db!.command({ dbCheck: target });
-            return {
-              success: true,
-              message: `Database check completed for ${target}: ${JSON.stringify(checkResult)}`,
-            };
-          }
-
-          case 'kill':
-            if (!target) {
-              throw new QueryError('Operation ID is required for kill operation', 'mongodb');
-            }
-            await this.db!.admin().command({ killOp: 1, op: parseInt(target, 10) });
-            return { success: true, message: `Killed operation: ${target}` };
-
-          default:
-            throw new QueryError(`Unsupported maintenance type for MongoDB: ${type}`, 'mongodb');
-        }
-      } catch (error) {
-        if (error instanceof QueryError) throw error;
-        throw mapDatabaseError(error, 'mongodb');
-      }
-    });
-
-    return {
-      success: result.success,
-      executionTime,
-      message: result.message,
-    };
-  }
-
-  // ============================================================================
-  // Monitoring Operations
-  // ============================================================================
-
-  public async getOverview(): Promise<DatabaseOverview> {
-    this.ensureConnected();
-
-    try {
-      const serverStatus = await this.db!.admin().serverStatus();
-      const dbStats = await this.db!.stats();
-      const serverInfo = await this.db!.admin().command({ buildInfo: 1 });
-
-      // Calculate uptime
-      const uptimeSeconds = serverStatus.uptime || 0;
-      const uptime = this.formatUptimeString(uptimeSeconds);
-
-      // Get collection count
-      const collections = await this.db!.listCollections().toArray();
-
-      // Get index count
-      let indexCount = 0;
-      for (const coll of collections) {
-        try {
-          const indexes = await this.db!.collection(coll.name).indexes();
-          indexCount += indexes.length;
-        } catch {
-          // Skip if can't get indexes
-        }
-      }
-
-      return {
-        version: `MongoDB ${serverInfo.version || 'Unknown'}`,
-        uptime,
-        startTime: new Date(Date.now() - uptimeSeconds * 1000),
-        activeConnections: serverStatus.connections?.current || 0,
-        maxConnections: serverStatus.connections?.available
-          ? serverStatus.connections.current + serverStatus.connections.available
-          : 100,
-        databaseSize: formatBytes(dbStats.dataSize || 0),
-        databaseSizeBytes: dbStats.dataSize || 0,
-        tableCount: collections.length,
-        indexCount,
-      };
-    } catch (error) {
-      this.logError('getOverview', error);
-      return {
-        version: 'MongoDB Unknown',
-        uptime: 'N/A',
-        activeConnections: 0,
-        maxConnections: 100,
-        databaseSize: 'N/A',
-        databaseSizeBytes: 0,
-        tableCount: 0,
-        indexCount: 0,
-      };
-    }
-  }
-
-  public async getPerformanceMetrics(): Promise<PerformanceMetrics> {
-    this.ensureConnected();
-
-    try {
-      const serverStatus = await this.db!.admin().serverStatus();
-
-      // Calculate cache hit ratio from WiredTiger
-      let cacheHitRatio = 99;
-      if (serverStatus.wiredTiger?.cache) {
-        const pagesRead = serverStatus.wiredTiger.cache['pages read into cache'] || 0;
-        const pagesRequested = serverStatus.wiredTiger.cache['pages requested from the cache'] || 1;
-        cacheHitRatio = Math.max(0, Math.min(100, (1 - pagesRead / Math.max(1, pagesRequested)) * 100));
-      }
-
-      // Calculate queries per second from opcounters
-      const opcounters = serverStatus.opcounters || {};
-      const uptimeSeconds = serverStatus.uptime || 1;
-      const totalOps = (opcounters.query || 0) + (opcounters.insert || 0) +
-                       (opcounters.update || 0) + (opcounters.delete || 0);
-      const queriesPerSecond = totalOps / uptimeSeconds;
-
-      // Get buffer pool usage (WiredTiger cache usage)
-      let bufferPoolUsage = 0;
-      if (serverStatus.wiredTiger?.cache) {
-        const bytesInCache = serverStatus.wiredTiger.cache['bytes currently in the cache'] || 0;
-        const maxCacheBytes = serverStatus.wiredTiger.cache['maximum bytes configured'] || 1;
-        bufferPoolUsage = (bytesInCache / maxCacheBytes) * 100;
-      }
-
-      return {
-        cacheHitRatio: Math.round(cacheHitRatio * 100) / 100,
-        queriesPerSecond: Math.round(queriesPerSecond * 100) / 100,
-        bufferPoolUsage: Math.round(bufferPoolUsage * 100) / 100,
-        deadlocks: 0, // MongoDB doesn't have traditional deadlocks
-      };
-    } catch (error) {
-      this.logError('getPerformanceMetrics', error);
-      return {
-        cacheHitRatio: 99,
-        queriesPerSecond: 0,
-        bufferPoolUsage: 0,
-        deadlocks: 0,
-      };
-    }
-  }
-
-  public async getSlowQueries(options?: { limit?: number }): Promise<SlowQueryStats[]> {
-    this.ensureConnected();
-    const limit = options?.limit ?? 10;
-
-    try {
-      // Try to get slow queries from system.profile
-      const profilerDocs = await this.db!.collection('system.profile')
-        .find({})
-        .sort({ millis: -1 })
-        .limit(limit)
-        .toArray();
-
-      return profilerDocs.map((doc) => ({
-        query: JSON.stringify(doc.command || doc.query || {}).substring(0, 500),
-        calls: 1,
-        totalTime: doc.millis || 0,
-        avgTime: doc.millis || 0,
-        rows: doc.nreturned || 0,
-      }));
-    } catch {
-      // Profiler not enabled or system.profile doesn't exist
-      return [];
-    }
-  }
-
-  public async getActiveSessions(options?: { limit?: number }): Promise<ActiveSessionDetails[]> {
-    this.ensureConnected();
-    const limit = options?.limit ?? 50;
-
-    try {
-      const currentOps = await this.db!.admin().command({ currentOp: 1, $all: true });
-
-      return (currentOps.inprog || [])
-        .slice(0, limit)
-        .map((op: Document) => {
-          const microseconds = op.microsecs_running || 0;
-          const durationMs = microseconds / 1000;
-
-          return {
-            pid: op.opid || 'N/A',
-            user: op.client || 'N/A',
-            database: op.ns?.split('.')[0] || this.getDatabaseName(),
-            applicationName: op.appName || undefined,
-            clientAddr: op.client?.split(':')[0] || undefined,
-            state: op.active ? 'active' : 'idle',
-            query: JSON.stringify(op.command || {}).substring(0, 500),
-            duration: this.formatDurationString(durationMs),
-            durationMs,
-            waitEventType: op.waitingForLock ? 'Lock' : undefined,
-            waitEvent: op.lockStats ? 'Acquiring lock' : undefined,
-          };
-        });
-    } catch (error) {
-      this.logError('getActiveSessions', error);
-      return [];
-    }
-  }
-
-  public async getTableStats(): Promise<TableStats[]> {
-    this.ensureConnected();
-
-    const collections = await this.db!.listCollections().toArray();
-    const stats: TableStats[] = [];
-
-    for (const collInfo of collections) {
-      const collName = collInfo.name;
-
-      try {
-        const collStats = await this.db!.command({ collStats: collName });
-
-        stats.push({
-          schemaName: this.getDatabaseName(),
-          tableName: collName,
-          rowCount: collStats.count || 0,
-          tableSize: formatBytes(collStats.size || 0),
-          tableSizeBytes: collStats.size || 0,
-          indexSize: formatBytes(collStats.totalIndexSize || 0),
-          totalSize: formatBytes((collStats.size || 0) + (collStats.totalIndexSize || 0)),
-          totalSizeBytes: (collStats.size || 0) + (collStats.totalIndexSize || 0),
-        });
-      } catch {
-        // Skip if can't get stats for this collection
-      }
-    }
-
-    // Sort by total size descending
-    return stats.sort((a, b) => b.totalSizeBytes - a.totalSizeBytes);
-  }
-
-  public async getIndexStats(): Promise<IndexStats[]> {
-    this.ensureConnected();
-
-    const collections = await this.db!.listCollections().toArray();
-    const stats: IndexStats[] = [];
-
-    for (const collInfo of collections) {
-      const collName = collInfo.name;
-      const collection = this.db!.collection(collName);
-
-      try {
-        // Get index stats using aggregation
-        const indexStatsDocs = await collection.aggregate([{ $indexStats: {} }]).toArray();
-
-        // Get index definitions
-        const indexes = await collection.indexes();
-
-        for (const idx of indexes) {
-          const indexStats = indexStatsDocs.find((s) => s.name === idx.name);
-
-          stats.push({
-            schemaName: this.getDatabaseName(),
-            tableName: collName,
-            indexName: idx.name || 'unknown',
-            indexType: idx.key ? Object.values(idx.key).includes('text') ? 'text' : 'btree' : 'btree',
-            columns: Object.keys(idx.key || {}),
-            isUnique: idx.unique || false,
-            isPrimary: idx.name === '_id_',
-            indexSize: 'N/A',
-            indexSizeBytes: 0,
-            scans: indexStats?.accesses?.ops || 0,
-          });
-        }
-      } catch {
-        // Skip if can't get index stats for this collection
-      }
-    }
-
-    return stats;
-  }
-
-  public async getStorageStats(): Promise<StorageStats[]> {
-    this.ensureConnected();
-
-    const stats: StorageStats[] = [];
-
-    try {
-      const dbStats = await this.db!.stats();
-      const serverStatus = await this.db!.admin().serverStatus();
-
-      // Database data size
-      stats.push({
-        name: 'Data',
-        location: this.getDatabaseName(),
-        size: formatBytes(dbStats.dataSize || 0),
-        sizeBytes: dbStats.dataSize || 0,
-      });
-
-      // Index size
-      stats.push({
-        name: 'Indexes',
-        size: formatBytes(dbStats.indexSize || 0),
-        sizeBytes: dbStats.indexSize || 0,
-      });
-
-      // Storage size (includes pre-allocated space)
-      stats.push({
-        name: 'Storage',
-        size: formatBytes(dbStats.storageSize || 0),
-        sizeBytes: dbStats.storageSize || 0,
-      });
-
-      // WiredTiger cache if available
-      if (serverStatus.wiredTiger?.cache) {
-        const bytesInCache = serverStatus.wiredTiger.cache['bytes currently in the cache'] || 0;
-        const maxCache = serverStatus.wiredTiger.cache['maximum bytes configured'] || 0;
-
-        stats.push({
-          name: 'WiredTiger Cache',
-          size: formatBytes(bytesInCache),
-          sizeBytes: bytesInCache,
-          usagePercent: maxCache > 0 ? (bytesInCache / maxCache) * 100 : 0,
-        });
-      }
-    } catch (error) {
-      this.logError('getStorageStats', error);
-    }
-
-    return stats;
-  }
-
-  private formatUptimeString(seconds: number): string {
-    const days = Math.floor(seconds / 86400);
-    const hours = Math.floor((seconds % 86400) / 3600);
-    const minutes = Math.floor((seconds % 3600) / 60);
-
-    if (days > 0) return `${days}d ${hours}h`;
-    if (hours > 0) return `${hours}h ${minutes}m`;
-    return `${minutes}m`;
-  }
-
-  private formatDurationString(ms: number): string {
-    if (ms < 1000) return `${Math.round(ms)}ms`;
-    if (ms < 60000) return `${(ms / 1000).toFixed(1)}s`;
-    if (ms < 3600000) return `${Math.floor(ms / 60000)}m ${Math.floor((ms % 60000) / 1000)}s`;
-    return `${Math.floor(ms / 3600000)}h ${Math.floor((ms % 3600000) / 60000)}m`;
-  }
-}