@libredb/studio 0.9.7 → 0.9.12

package/dist/mongodb-XMZEZA4A.mjs

@@ -0,0 +1,748 @@
+import { BaseDatabaseProvider, formatBytes } from './chunk-QJP5FZRY.mjs';
+import { DatabaseConfigError, ConnectionError, QueryError, mapDatabaseError } from './chunk-CZVV3JJB.mjs';
+import './chunk-4LVB3K53.mjs';
+import { MongoClient, ObjectId, Binary, Decimal128 } from 'mongodb';
+
+var MongoDBProvider = class extends BaseDatabaseProvider {
+  constructor(config, options = {}) {
+    super(config, options);
+    this.client = null;
+    this.db = null;
+    this.validate();
+  }
+  // ============================================================================
+  // Provider Metadata
+  // ============================================================================
+  getCapabilities() {
+    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)'
+    };
+  }
+  getLabels() {
+    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."
+    };
+  }
+  prepareQuery(query, options = {}) {
+    return { query, wasLimited: false, limit: options.limit || 100, offset: 0 };
+  }
+  // ============================================================================
+  // Validation
+  // ============================================================================
+  validate() {
+    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
+  // ============================================================================
+  async connect() {
+    if (this.client && this.db) {
+      return;
+    }
+    try {
+      const connectionString = this.buildConnectionString();
+      const options = {
+        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();
+      const dbName = this.getDatabaseName();
+      this.db = this.client.db(dbName);
+      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
+      );
+    }
+  }
+  async disconnect() {
+    if (this.client) {
+      try {
+        await this.client.close();
+      } finally {
+        this.client = null;
+        this.db = null;
+        this.setConnected(false);
+      }
+    }
+  }
+  buildConnectionString() {
+    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}`;
+  }
+  getDatabaseName() {
+    if (this.config.database) {
+      return this.config.database;
+    }
+    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"}]}
+   */
+  async query(queryStr) {
+    this.ensureConnected();
+    return this.trackQuery(async () => {
+      const { result, executionTime } = await this.measureExecution(async () => {
+        var _a, _b, _c, _d, _e, _f;
+        try {
+          const query = this.parseQuery(queryStr);
+          const collection = this.db.collection(query.collection);
+          let rows = [];
+          let affectedCount = 0;
+          switch (query.operation) {
+            case "find": {
+              const cursor = collection.find(query.filter || {});
+              if ((_a = query.options) == null ? void 0 : _a.projection) cursor.project(query.options.projection);
+              if ((_b = query.options) == null ? void 0 : _b.sort) cursor.sort(query.options.sort);
+              if ((_c = query.options) == null ? void 0 : _c.skip) cursor.skip(query.options.skip);
+              if ((_d = query.options) == null ? void 0 : _d.limit) cursor.limit(query.options.limit);
+              else cursor.limit(100);
+              try {
+                rows = await cursor.toArray();
+              } finally {
+                await cursor.close();
+              }
+              break;
+            }
+            case "findOne": {
+              const doc = await collection.findOne(query.filter || {}, {
+                projection: (_e = query.options) == null ? void 0 : _e.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 = ((_f = query.options) == null ? void 0 : _f.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");
+          }
+          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
+      };
+    });
+  }
+  parseQuery(queryStr) {
+    try {
+      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;
+    } 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"
+      );
+    }
+  }
+  serializeDocument(doc) {
+    const serialized = {};
+    for (const [key, value] of Object.entries(doc)) {
+      if (value === null || value === void 0) {
+        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);
+        }
+      } else {
+        serialized[key] = value;
+      }
+    }
+    return serialized;
+  }
+  // ============================================================================
+  // Schema Operations
+  // ============================================================================
+  /**
+   * Get schema by listing collections and sampling documents to infer field types
+   */
+  async getSchema() {
+    this.ensureConnected();
+    const allCollections = await this.db.listCollections().toArray();
+    const collections = allCollections.filter((c) => !c.name.startsWith("system.")).slice(0, 200);
+    const schemas = [];
+    for (const collInfo of collections) {
+      const collName = collInfo.name;
+      const collection = this.db.collection(collName);
+      const rowCount = await collection.estimatedDocumentCount();
+      let sizeBytes = 0;
+      try {
+        const stats = await this.db.command({ collStats: collName });
+        sizeBytes = stats.size || 0;
+      } catch (e) {
+      }
+      const sampleDocs = await collection.find({}).limit(100).toArray();
+      const columns = this.inferSchemaFromDocuments(sampleDocs);
+      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;
+  }
+  inferSchemaFromDocuments(docs) {
+    const fieldTypes = /* @__PURE__ */ new Map();
+    for (const doc of docs) {
+      this.extractFieldTypes(doc, "", fieldTypes);
+    }
+    const columns = [];
+    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: void 0
+      });
+    }
+    columns.sort((a, b) => {
+      if (a.name === "_id") return -1;
+      if (b.name === "_id") return 1;
+      return a.name.localeCompare(b.name);
+    });
+    return columns;
+  }
+  extractFieldTypes(doc, prefix, fieldTypes) {
+    for (const [key, value] of Object.entries(doc)) {
+      const fieldName = prefix ? `${prefix}.${key}` : key;
+      if (!fieldTypes.has(fieldName)) {
+        fieldTypes.set(fieldName, /* @__PURE__ */ new Set());
+      }
+      const type = this.getMongoType(value);
+      fieldTypes.get(fieldName).add(type);
+    }
+  }
+  getMongoType(value) {
+    if (value === null) return "null";
+    if (value === void 0) 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
+  // ============================================================================
+  async getHealth() {
+    var _a, _b;
+    this.ensureConnected();
+    try {
+      const serverStatus = await this.db.admin().serverStatus();
+      const dbStats = await this.db.stats();
+      const currentOps = await this.db.admin().command({ currentOp: 1 });
+      const activeSessions = (currentOps.inprog || []).slice(0, 10).map((op) => ({
+        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 / 1e6).toFixed(2)}s` : "N/A"
+      }));
+      const slowQueries = [];
+      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 (e) {
+        slowQueries.push({
+          query: "Profiler not enabled. Run db.setProfilingLevel(1) to enable.",
+          calls: 0,
+          avgTime: "N/A"
+        });
+      }
+      return {
+        activeConnections: ((_a = serverStatus.connections) == null ? void 0 : _a.current) || 0,
+        databaseSize: formatBytes(dbStats.dataSize || 0),
+        cacheHitRatio: ((_b = serverStatus.wiredTiger) == null ? void 0 : _b.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
+  // ============================================================================
+  async runMaintenance(type, target) {
+    this.ensureConnected();
+    const { result, executionTime } = await this.measureExecution(async () => {
+      try {
+        switch (type) {
+          case "analyze":
+            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":
+            return {
+              success: false,
+              message: "Reindex is not supported in MongoDB 6.0+. Use compact instead to defragment collections."
+            };
+          case "vacuum":
+          case "optimize":
+            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 (e) {
+                }
+              }
+              return { success: true, message: `Compacted collections` };
+            }
+          case "check": {
+            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
+  // ============================================================================
+  async getOverview() {
+    var _a, _b;
+    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 });
+      const uptimeSeconds = serverStatus.uptime || 0;
+      const uptime = this.formatUptimeString(uptimeSeconds);
+      const collections = await this.db.listCollections().toArray();
+      let indexCount = 0;
+      for (const coll of collections) {
+        try {
+          const indexes = await this.db.collection(coll.name).indexes();
+          indexCount += indexes.length;
+        } catch (e) {
+        }
+      }
+      return {
+        version: `MongoDB ${serverInfo.version || "Unknown"}`,
+        uptime,
+        startTime: new Date(Date.now() - uptimeSeconds * 1e3),
+        activeConnections: ((_a = serverStatus.connections) == null ? void 0 : _a.current) || 0,
+        maxConnections: ((_b = serverStatus.connections) == null ? void 0 : _b.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
+      };
+    }
+  }
+  async getPerformanceMetrics() {
+    var _a, _b;
+    this.ensureConnected();
+    try {
+      const serverStatus = await this.db.admin().serverStatus();
+      let cacheHitRatio = 99;
+      if ((_a = serverStatus.wiredTiger) == null ? void 0 : _a.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));
+      }
+      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;
+      let bufferPoolUsage = 0;
+      if ((_b = serverStatus.wiredTiger) == null ? void 0 : _b.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
+      };
+    }
+  }
+  async getSlowQueries(options) {
+    var _a;
+    this.ensureConnected();
+    const limit = (_a = options == null ? void 0 : options.limit) != null ? _a : 10;
+    try {
+      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 (e) {
+      return [];
+    }
+  }
+  async getActiveSessions(options) {
+    var _a;
+    this.ensureConnected();
+    const limit = (_a = options == null ? void 0 : options.limit) != null ? _a : 50;
+    try {
+      const currentOps = await this.db.admin().command({ currentOp: 1, $all: true });
+      return (currentOps.inprog || []).slice(0, limit).map((op) => {
+        var _a2, _b;
+        const microseconds = op.microsecs_running || 0;
+        const durationMs = microseconds / 1e3;
+        return {
+          pid: op.opid || "N/A",
+          user: op.client || "N/A",
+          database: ((_a2 = op.ns) == null ? void 0 : _a2.split(".")[0]) || this.getDatabaseName(),
+          applicationName: op.appName || void 0,
+          clientAddr: ((_b = op.client) == null ? void 0 : _b.split(":")[0]) || void 0,
+          state: op.active ? "active" : "idle",
+          query: JSON.stringify(op.command || {}).substring(0, 500),
+          duration: this.formatDurationString(durationMs),
+          durationMs,
+          waitEventType: op.waitingForLock ? "Lock" : void 0,
+          waitEvent: op.lockStats ? "Acquiring lock" : void 0
+        };
+      });
+    } catch (error) {
+      this.logError("getActiveSessions", error);
+      return [];
+    }
+  }
+  async getTableStats() {
+    this.ensureConnected();
+    const collections = await this.db.listCollections().toArray();
+    const stats = [];
+    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 (e) {
+      }
+    }
+    return stats.sort((a, b) => b.totalSizeBytes - a.totalSizeBytes);
+  }
+  async getIndexStats() {
+    var _a;
+    this.ensureConnected();
+    const collections = await this.db.listCollections().toArray();
+    const stats = [];
+    for (const collInfo of collections) {
+      const collName = collInfo.name;
+      const collection = this.db.collection(collName);
+      try {
+        const indexStatsDocs = await collection.aggregate([{ $indexStats: {} }]).toArray();
+        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: ((_a = indexStats == null ? void 0 : indexStats.accesses) == null ? void 0 : _a.ops) || 0
+          });
+        }
+      } catch (e) {
+      }
+    }
+    return stats;
+  }
+  async getStorageStats() {
+    var _a;
+    this.ensureConnected();
+    const stats = [];
+    try {
+      const dbStats = await this.db.stats();
+      const serverStatus = await this.db.admin().serverStatus();
+      stats.push({
+        name: "Data",
+        location: this.getDatabaseName(),
+        size: formatBytes(dbStats.dataSize || 0),
+        sizeBytes: dbStats.dataSize || 0
+      });
+      stats.push({
+        name: "Indexes",
+        size: formatBytes(dbStats.indexSize || 0),
+        sizeBytes: dbStats.indexSize || 0
+      });
+      stats.push({
+        name: "Storage",
+        size: formatBytes(dbStats.storageSize || 0),
+        sizeBytes: dbStats.storageSize || 0
+      });
+      if ((_a = serverStatus.wiredTiger) == null ? void 0 : _a.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;
+  }
+  formatUptimeString(seconds) {
+    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`;
+  }
+  formatDurationString(ms) {
+    if (ms < 1e3) return `${Math.round(ms)}ms`;
+    if (ms < 6e4) return `${(ms / 1e3).toFixed(1)}s`;
+    if (ms < 36e5) return `${Math.floor(ms / 6e4)}m ${Math.floor(ms % 6e4 / 1e3)}s`;
+    return `${Math.floor(ms / 36e5)}h ${Math.floor(ms % 36e5 / 6e4)}m`;
+  }
+};
+
+export { MongoDBProvider };
+//# sourceMappingURL=mongodb-XMZEZA4A.mjs.map
+//# sourceMappingURL=mongodb-XMZEZA4A.mjs.map