mongodb-data-service 22.37.2 → 22.38.1

package/lib/data-service.js

@@ -137,7 +137,6 @@ function op(logId, pickLogAttrs = maybePickNs) {
     };
 }
 let DataServiceImpl = (() => {
-    var _a;
     let _classSuper = logger_1.WithLogContext;
     let _instanceExtraInitializers = [];
     let _collectionStats_decorators;
@@ -188,1589 +187,1608 @@ let DataServiceImpl = (() => {
     let _startStreamProcessor_decorators;
     let _stopStreamProcessor_decorators;
     let _dropStreamProcessor_decorators;
-    return _a = class DataServiceImpl extends _classSuper {
-            _getOptionsWithFallbackReadPreference(options, executionOptions) {
-                const readPreferencesOverride = isReadPreferenceSet(this._connectionOptions.connectionString)
-                    ? undefined
-                    : executionOptions?.fallbackReadPreference;
-                if (!readPreferencesOverride) {
-                    return options;
+    return class DataServiceImpl extends _classSuper {
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+            _collectionStats_decorators = [op((0, logger_1.mongoLogId)(1_001_000_178), ([dbName, collName], result) => {
+                    return { ns: `${dbName}.${collName}`, ...(result && { result }) };
+                })];
+            _collectionInfo_decorators = [op((0, logger_1.mongoLogId)(1_001_000_179))];
+            _killOp_decorators = [op((0, logger_1.mongoLogId)(1_001_000_031))];
+            __connectionStatus_decorators = [op((0, logger_1.mongoLogId)(1_001_000_100))];
+            _listCollections_decorators = [op((0, logger_1.mongoLogId)(1_001_000_032), ([databaseName, , options], colls) => {
+                    return {
+                        db: databaseName,
+                        nameOnly: options?.nameOnly ?? false,
+                        ...(colls && { collectionsCount: colls.length }),
+                    };
+                })];
+            _listDatabases_decorators = [op((0, logger_1.mongoLogId)(1_001_000_033), ([options], dbs) => {
+                    return {
+                        nameOnly: options?.nameOnly ?? false,
+                        ...(dbs && { databasesCount: dbs.length }),
+                    };
+                })];
+            _estimatedCount_decorators = [op((0, logger_1.mongoLogId)(1_001_000_034), ([ns, options]) => {
+                    return { ns, maxTimeMS: options?.maxTimeMS };
+                })];
+            _count_decorators = [op((0, logger_1.mongoLogId)(1_001_000_035))];
+            _createCollection_decorators = [op((0, logger_1.mongoLogId)(1_001_000_036), ([ns, options], result) => {
+                    return { ns, options, ...(result && { result }) };
+                })];
+            _createIndex_decorators = [op((0, logger_1.mongoLogId)(1_001_000_037), ([ns, spec, options], result) => {
+                    return { ns, spec, options, ...(result && { result }) };
+                })];
+            _deleteOne_decorators = [op((0, logger_1.mongoLogId)(1_001_000_038), ([ns], result) => {
+                    return { ns, ...(result && { result }) };
+                })];
+            _deleteMany_decorators = [op((0, logger_1.mongoLogId)(1_001_000_039), ([ns], result) => {
+                    return { ns, ...(result && { result }) };
+                })];
+            _dropCollection_decorators = [op((0, logger_1.mongoLogId)(1_001_000_059), ([ns], result) => {
+                    return { ns, ...(result && { result }) };
+                })];
+            _renameCollection_decorators = [op((0, logger_1.mongoLogId)(1_001_000_276))];
+            _dropDatabase_decorators = [op((0, logger_1.mongoLogId)(1_001_000_040), ([db], result) => {
+                    return { db, ...(result && { result }) };
+                })];
+            _dropIndex_decorators = [op((0, logger_1.mongoLogId)(1_001_000_182), ([ns, name], result) => {
+                    return { ns, name, ...(result && { result }) };
+                })];
+            _isListSearchIndexesSupported_decorators = [op((0, logger_1.mongoLogId)(1_001_000_237))];
+            _getSearchIndexes_decorators = [op((0, logger_1.mongoLogId)(1_001_000_238))];
+            _createSearchIndex_decorators = [op((0, logger_1.mongoLogId)(1_001_000_239))];
+            _updateSearchIndex_decorators = [op((0, logger_1.mongoLogId)(1_001_000_240))];
+            _dropSearchIndex_decorators = [op((0, logger_1.mongoLogId)(1_001_000_241))];
+            _aggregateCursor_decorators = [op((0, logger_1.mongoLogId)(1_001_000_041), ([ns, pipeline, options]) => {
+                    return {
+                        ns,
+                        stages: pipeline.map((stage) => Object.keys(stage)[0]),
+                        maxTimeMS: options?.maxTimeMS,
+                    };
+                })];
+            _aggregate_decorators = [op((0, logger_1.mongoLogId)(1_001_000_181), ([ns, pipeline, options]) => {
+                    return {
+                        ns,
+                        stages: pipeline.map((stage) => Object.keys(stage)[0]),
+                        maxTimeMS: options?.maxTimeMS,
+                    };
+                })];
+            _find_decorators = [op((0, logger_1.mongoLogId)(1_001_000_060), ([ns, , options]) => {
+                    return { ns, maxTimeMS: options?.maxTimeMS };
+                })];
+            _findCursor_decorators = [op((0, logger_1.mongoLogId)(1_001_000_043))];
+            _findOneAndReplace_decorators = [op((0, logger_1.mongoLogId)(1_001_000_044))];
+            _findOneAndUpdate_decorators = [op((0, logger_1.mongoLogId)(1_001_000_045))];
+            _updateOne_decorators = [op((0, logger_1.mongoLogId)(1_001_000_183))];
+            _replaceOne_decorators = [op((0, logger_1.mongoLogId)(1_001_000_191))];
+            _explainFind_decorators = [op((0, logger_1.mongoLogId)(1_001_000_046), ([ns, , , executionOptions]) => {
+                    return {
+                        ns,
+                        verbosity: executionOptions?.explainVerbosity || mongodb_1.ExplainVerbosity.executionStats,
+                    };
+                })];
+            _explainAggregate_decorators = [op((0, logger_1.mongoLogId)(1_001_000_177), ([ns, , , executionOptions]) => {
+                    return {
+                        ns,
+                        verbosity: executionOptions?.explainVerbosity || mongodb_1.ExplainVerbosity.executionStats,
+                    };
+                })];
+            _fetchShardKey_decorators = [op((0, logger_1.mongoLogId)(1_001_000_381))];
+            _indexes_decorators = [op((0, logger_1.mongoLogId)(1_001_000_047))];
+            _instance_decorators = [op((0, logger_1.mongoLogId)(1_001_000_024), (_, instanceData) => {
+                    if (instanceData) {
+                        return {
+                            serverVersion: instanceData.build.version,
+                            genuineMongoDB: instanceData.genuineMongoDB,
+                            dataLake: instanceData.dataLake,
+                            featureCompatibilityVersion: instanceData.featureCompatibilityVersion,
+                        };
+                    }
+                })];
+            _insertOne_decorators = [op((0, logger_1.mongoLogId)(1_001_000_048), ([ns], result) => {
+                    return { ns, ...(result && { acknowledged: result.acknowledged }) };
+                })];
+            _insertMany_decorators = [op((0, logger_1.mongoLogId)(1_001_000_049), ([ns], result) => {
+                    return {
+                        ns,
+                        ...(result && {
+                            acknowledged: result.acknowledged,
+                            insertedCount: result.insertedCount,
+                        }),
+                    };
+                })];
+            _updateCollection_decorators = [op((0, logger_1.mongoLogId)(1_001_000_050), ([ns], result) => {
+                    return { ns, ...(result && { result }) };
+                })];
+            _currentOp_decorators = [op((0, logger_1.mongoLogId)(1_001_000_053))];
+            _serverStatus_decorators = [op((0, logger_1.mongoLogId)(1_001_000_061), (_, result) => {
+                    return result ? { result } : undefined;
+                })];
+            _top_decorators = [op((0, logger_1.mongoLogId)(1_001_000_062), (_, result) => {
+                    return result ? { result } : undefined;
+                })];
+            _createView_decorators = [op((0, logger_1.mongoLogId)(1_001_000_055), ([name, sourceNs, pipeline, options], result) => {
+                    return {
+                        name,
+                        sourceNs,
+                        stages: pipeline.map((stage) => Object.keys(stage)[0]),
+                        options,
+                        ...(result && { result }),
+                    };
+                })];
+            _databaseStats_decorators = [op((0, logger_1.mongoLogId)(1_001_000_057))];
+            _previewUpdate_decorators = [op((0, logger_1.mongoLogId)(1_001_000_266))];
+            _createDataKey_decorators = [op((0, logger_1.mongoLogId)(1_001_000_123), ([provider]) => {
+                    return { provider };
+                })];
+            _listStreamProcessors_decorators = [op((0, logger_1.mongoLogId)(1_001_000_284))];
+            _startStreamProcessor_decorators = [op((0, logger_1.mongoLogId)(1_001_000_285))];
+            _stopStreamProcessor_decorators = [op((0, logger_1.mongoLogId)(1_001_000_286))];
+            _dropStreamProcessor_decorators = [op((0, logger_1.mongoLogId)(1_001_000_287))];
+            __esDecorate(this, null, _collectionStats_decorators, { kind: "method", name: "collectionStats", static: false, private: false, access: { has: obj => "collectionStats" in obj, get: obj => obj.collectionStats }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _collectionInfo_decorators, { kind: "method", name: "collectionInfo", static: false, private: false, access: { has: obj => "collectionInfo" in obj, get: obj => obj.collectionInfo }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _killOp_decorators, { kind: "method", name: "killOp", static: false, private: false, access: { has: obj => "killOp" in obj, get: obj => obj.killOp }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, __connectionStatus_decorators, { kind: "method", name: "_connectionStatus", static: false, private: false, access: { has: obj => "_connectionStatus" in obj, get: obj => obj._connectionStatus }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _listCollections_decorators, { kind: "method", name: "listCollections", static: false, private: false, access: { has: obj => "listCollections" in obj, get: obj => obj.listCollections }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _listDatabases_decorators, { kind: "method", name: "listDatabases", static: false, private: false, access: { has: obj => "listDatabases" in obj, get: obj => obj.listDatabases }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _estimatedCount_decorators, { kind: "method", name: "estimatedCount", static: false, private: false, access: { has: obj => "estimatedCount" in obj, get: obj => obj.estimatedCount }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _count_decorators, { kind: "method", name: "count", static: false, private: false, access: { has: obj => "count" in obj, get: obj => obj.count }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _createCollection_decorators, { kind: "method", name: "createCollection", static: false, private: false, access: { has: obj => "createCollection" in obj, get: obj => obj.createCollection }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _createIndex_decorators, { kind: "method", name: "createIndex", static: false, private: false, access: { has: obj => "createIndex" in obj, get: obj => obj.createIndex }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _deleteOne_decorators, { kind: "method", name: "deleteOne", static: false, private: false, access: { has: obj => "deleteOne" in obj, get: obj => obj.deleteOne }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _deleteMany_decorators, { kind: "method", name: "deleteMany", static: false, private: false, access: { has: obj => "deleteMany" in obj, get: obj => obj.deleteMany }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _dropCollection_decorators, { kind: "method", name: "dropCollection", static: false, private: false, access: { has: obj => "dropCollection" in obj, get: obj => obj.dropCollection }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _renameCollection_decorators, { kind: "method", name: "renameCollection", static: false, private: false, access: { has: obj => "renameCollection" in obj, get: obj => obj.renameCollection }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _dropDatabase_decorators, { kind: "method", name: "dropDatabase", static: false, private: false, access: { has: obj => "dropDatabase" in obj, get: obj => obj.dropDatabase }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _dropIndex_decorators, { kind: "method", name: "dropIndex", static: false, private: false, access: { has: obj => "dropIndex" in obj, get: obj => obj.dropIndex }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _isListSearchIndexesSupported_decorators, { kind: "method", name: "isListSearchIndexesSupported", static: false, private: false, access: { has: obj => "isListSearchIndexesSupported" in obj, get: obj => obj.isListSearchIndexesSupported }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _getSearchIndexes_decorators, { kind: "method", name: "getSearchIndexes", static: false, private: false, access: { has: obj => "getSearchIndexes" in obj, get: obj => obj.getSearchIndexes }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _createSearchIndex_decorators, { kind: "method", name: "createSearchIndex", static: false, private: false, access: { has: obj => "createSearchIndex" in obj, get: obj => obj.createSearchIndex }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _updateSearchIndex_decorators, { kind: "method", name: "updateSearchIndex", static: false, private: false, access: { has: obj => "updateSearchIndex" in obj, get: obj => obj.updateSearchIndex }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _dropSearchIndex_decorators, { kind: "method", name: "dropSearchIndex", static: false, private: false, access: { has: obj => "dropSearchIndex" in obj, get: obj => obj.dropSearchIndex }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _aggregateCursor_decorators, { kind: "method", name: "aggregateCursor", static: false, private: false, access: { has: obj => "aggregateCursor" in obj, get: obj => obj.aggregateCursor }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _aggregate_decorators, { kind: "method", name: "aggregate", static: false, private: false, access: { has: obj => "aggregate" in obj, get: obj => obj.aggregate }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _find_decorators, { kind: "method", name: "find", static: false, private: false, access: { has: obj => "find" in obj, get: obj => obj.find }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _findCursor_decorators, { kind: "method", name: "findCursor", static: false, private: false, access: { has: obj => "findCursor" in obj, get: obj => obj.findCursor }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _findOneAndReplace_decorators, { kind: "method", name: "findOneAndReplace", static: false, private: false, access: { has: obj => "findOneAndReplace" in obj, get: obj => obj.findOneAndReplace }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _findOneAndUpdate_decorators, { kind: "method", name: "findOneAndUpdate", static: false, private: false, access: { has: obj => "findOneAndUpdate" in obj, get: obj => obj.findOneAndUpdate }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _updateOne_decorators, { kind: "method", name: "updateOne", static: false, private: false, access: { has: obj => "updateOne" in obj, get: obj => obj.updateOne }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _replaceOne_decorators, { kind: "method", name: "replaceOne", static: false, private: false, access: { has: obj => "replaceOne" in obj, get: obj => obj.replaceOne }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _explainFind_decorators, { kind: "method", name: "explainFind", static: false, private: false, access: { has: obj => "explainFind" in obj, get: obj => obj.explainFind }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _explainAggregate_decorators, { kind: "method", name: "explainAggregate", static: false, private: false, access: { has: obj => "explainAggregate" in obj, get: obj => obj.explainAggregate }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _fetchShardKey_decorators, { kind: "method", name: "fetchShardKey", static: false, private: false, access: { has: obj => "fetchShardKey" in obj, get: obj => obj.fetchShardKey }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _indexes_decorators, { kind: "method", name: "indexes", static: false, private: false, access: { has: obj => "indexes" in obj, get: obj => obj.indexes }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _instance_decorators, { kind: "method", name: "instance", static: false, private: false, access: { has: obj => "instance" in obj, get: obj => obj.instance }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _insertOne_decorators, { kind: "method", name: "insertOne", static: false, private: false, access: { has: obj => "insertOne" in obj, get: obj => obj.insertOne }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _insertMany_decorators, { kind: "method", name: "insertMany", static: false, private: false, access: { has: obj => "insertMany" in obj, get: obj => obj.insertMany }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _updateCollection_decorators, { kind: "method", name: "updateCollection", static: false, private: false, access: { has: obj => "updateCollection" in obj, get: obj => obj.updateCollection }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _currentOp_decorators, { kind: "method", name: "currentOp", static: false, private: false, access: { has: obj => "currentOp" in obj, get: obj => obj.currentOp }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _serverStatus_decorators, { kind: "method", name: "serverStatus", static: false, private: false, access: { has: obj => "serverStatus" in obj, get: obj => obj.serverStatus }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _top_decorators, { kind: "method", name: "top", static: false, private: false, access: { has: obj => "top" in obj, get: obj => obj.top }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _createView_decorators, { kind: "method", name: "createView", static: false, private: false, access: { has: obj => "createView" in obj, get: obj => obj.createView }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _databaseStats_decorators, { kind: "method", name: "databaseStats", static: false, private: false, access: { has: obj => "databaseStats" in obj, get: obj => obj.databaseStats }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _previewUpdate_decorators, { kind: "method", name: "previewUpdate", static: false, private: false, access: { has: obj => "previewUpdate" in obj, get: obj => obj.previewUpdate }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _createDataKey_decorators, { kind: "method", name: "createDataKey", static: false, private: false, access: { has: obj => "createDataKey" in obj, get: obj => obj.createDataKey }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _listStreamProcessors_decorators, { kind: "method", name: "listStreamProcessors", static: false, private: false, access: { has: obj => "listStreamProcessors" in obj, get: obj => obj.listStreamProcessors }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _startStreamProcessor_decorators, { kind: "method", name: "startStreamProcessor", static: false, private: false, access: { has: obj => "startStreamProcessor" in obj, get: obj => obj.startStreamProcessor }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _stopStreamProcessor_decorators, { kind: "method", name: "stopStreamProcessor", static: false, private: false, access: { has: obj => "stopStreamProcessor" in obj, get: obj => obj.stopStreamProcessor }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _dropStreamProcessor_decorators, { kind: "method", name: "dropStreamProcessor", static: false, private: false, access: { has: obj => "dropStreamProcessor" in obj, get: obj => obj.dropStreamProcessor }, metadata: _metadata }, null, _instanceExtraInitializers);
+            if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        }
+        _connectionOptions = __runInitializers(this, _instanceExtraInitializers);
+        _proxyOptions;
+        _isConnecting = false;
+        _mongoClientConnectionOptions;
+        // Use two separate clients in the CSFLE case, one with CSFLE
+        // enabled, one disabled. _initializedClient() can be used
+        // to fetch the right one. _useCRUDClient can be used to control
+        // this behavior after connecting, i.e. for disabling and
+        // enabling CSFLE on an already-connected DataService instance.
+        _metadataClient;
+        _crudClient;
+        _useCRUDClient = true;
+        _csfleCollectionTracker;
+        _tunnel;
+        _state;
+        _reauthenticationHandlers = new Set();
+        /**
+         * Stores the most recent topology description from the server's SDAM events:
+         * https://github.com/mongodb/specifications/blob/master/source/server-discovery-and-monitoring/server-discovery-and-monitoring-monitoring.rst#events
+         */
+        _lastSeenTopology = null;
+        _isWritable = false;
+        _id;
+        _emitter = new events_1.EventEmitter();
+        /**
+         * Directly used during data-service runtime, auto sets component and context
+         * with a connection id
+         */
+        _logger;
+        /**
+         * To be passed to the connect-mongo-client
+         */
+        _unboundLogger;
+        _getOptionsWithFallbackReadPreference(options, executionOptions) {
+            const readPreferencesOverride = isReadPreferenceSet(this._connectionOptions.connectionString)
+                ? undefined
+                : executionOptions?.fallbackReadPreference;
+            if (!readPreferencesOverride) {
+                return options;
+            }
+            return {
+                ...options,
+                readPreference: readPreferencesOverride,
+            };
+        }
+        constructor(connectionOptions, logger, proxyOptions) {
+            super();
+            this._id = id++;
+            this._connectionOptions = connectionOptions;
+            this._proxyOptions = proxyOptions ?? {};
+            const logComponent = 'COMPASS-DATA-SERVICE';
+            const logCtx = `Connection ${this._id}`;
+            this._logger = {
+                debug: (logId, ...args) => {
+                    return logger?.debug(logComponent, logId, logCtx, ...args);
+                },
+                info: (logId, ...args) => {
+                    return logger?.info(logComponent, logId, logCtx, ...args);
+                },
+                warn: (logId, ...args) => {
+                    return logger?.warn(logComponent, logId, logCtx, ...args);
+                },
+                error: (logId, ...args) => {
+                    return logger?.error(logComponent, logId, logCtx, ...args);
+                },
+                fatal: (logId, ...args) => {
+                    return logger?.fatal(logComponent, logId, logCtx, ...args);
+                },
+            };
+            if (logger) {
+                this._unboundLogger = Object.assign(logger, { mongoLogId: logger_1.mongoLogId });
+            }
+        }
+        get id() {
+            return this._id;
+        }
+        on(...args) {
+            this._emitter.on(...args);
+            return this;
+        }
+        off(...args) {
+            this._emitter.off(...args);
+            return this;
+        }
+        removeListener(...args) {
+            this._emitter.off(...args);
+            return this;
+        }
+        once(...args) {
+            this._emitter.once(...args);
+            return this;
+        }
+        getMongoClientConnectionOptions() {
+            // `notifyDeviceFlow` is a function which cannot be serialized for inclusion
+            // in the shell, `signal` is an abortSignal, and `allowedFlows` is turned
+            // into a function by the connection code.
+            return (0, lodash_1.omit)(this._mongoClientConnectionOptions, 'options.oidc.notifyDeviceFlow', 'options.oidc.signal', 'options.oidc.allowedFlows', 'options.oidc.customFetch', 'options.oidc.customHttpOptions');
+        }
+        getConnectionOptions() {
+            return this._connectionOptions;
+        }
+        getConnectionString() {
+            return new mongodb_connection_string_url_1.default(this._connectionOptions.connectionString);
+        }
+        setCSFLEEnabled(enabled) {
+            this._logger.info((0, logger_1.mongoLogId)(1_001_000_117), 'Setting CSFLE mode', {
+                enabled,
+            });
+            this._useCRUDClient = enabled;
+        }
+        getCSFLEMode() {
+            if (this._crudClient && (0, instance_detail_helper_2.checkIsCSFLEConnection)(this._crudClient)) {
+                if (this._useCRUDClient) {
+                    return 'enabled';
+                }
+                else {
+                    return 'disabled';
                 }
-                return {
-                    ...options,
-                    readPreference: readPreferencesOverride,
-                };
             }
-            constructor(connectionOptions, logger, proxyOptions) {
-                super();
-                this._connectionOptions = __runInitializers(this, _instanceExtraInitializers);
-                this._isConnecting = false;
-                this._useCRUDClient = true;
-                this._reauthenticationHandlers = new Set();
-                /**
-                 * Stores the most recent topology description from the server's SDAM events:
-                 * https://github.com/mongodb/specifications/blob/master/source/server-discovery-and-monitoring/server-discovery-and-monitoring-monitoring.rst#events
-                 */
-                this._lastSeenTopology = null;
-                this._isWritable = false;
-                this._emitter = new events_1.EventEmitter();
-                this._id = id++;
-                this._connectionOptions = connectionOptions;
-                this._proxyOptions = proxyOptions ?? {};
-                const logComponent = 'COMPASS-DATA-SERVICE';
-                const logCtx = `Connection ${this._id}`;
-                this._logger = {
-                    debug: (logId, ...args) => {
-                        return logger?.debug(logComponent, logId, logCtx, ...args);
-                    },
-                    info: (logId, ...args) => {
-                        return logger?.info(logComponent, logId, logCtx, ...args);
+            else {
+                return 'unavailable';
+            }
+        }
+        async collectionStats(databaseName, collectionName, collectionType) {
+            const ns = `${databaseName}.${collectionName}`;
+            try {
+                const coll = this._collection(ns, 'CRUD');
+                // Build the aggregation pipeline dynamically based on collection type
+                const groupStage = {
+                    _id: null,
+                    capped: { $first: '$storageStats.capped' },
+                    count: { $sum: '$storageStats.count' },
+                    size: { $sum: { $toDouble: '$storageStats.size' } },
+                    storageSize: {
+                        $sum: { $toDouble: '$storageStats.storageSize' },
                     },
-                    warn: (logId, ...args) => {
-                        return logger?.warn(logComponent, logId, logCtx, ...args);
+                    totalIndexSize: {
+                        $sum: { $toDouble: '$storageStats.totalIndexSize' },
                     },
-                    error: (logId, ...args) => {
-                        return logger?.error(logComponent, logId, logCtx, ...args);
+                    freeStorageSize: {
+                        $sum: { $toDouble: '$storageStats.freeStorageSize' },
                     },
-                    fatal: (logId, ...args) => {
-                        return logger?.fatal(logComponent, logId, logCtx, ...args);
+                    unscaledCollSize: {
+                        $sum: {
+                            $multiply: [
+                                { $toDouble: '$storageStats.avgObjSize' },
+                                { $toDouble: '$storageStats.count' },
+                            ],
+                        },
                     },
+                    nindexes: { $max: '$storageStats.nindexes' },
                 };
-                if (logger) {
-                    this._unboundLogger = Object.assign(logger, { mongoLogId: logger_1.mongoLogId });
-                }
-            }
-            get id() {
-                return this._id;
-            }
-            on(...args) {
-                this._emitter.on(...args);
-                return this;
-            }
-            off(...args) {
-                this._emitter.off(...args);
-                return this;
-            }
-            removeListener(...args) {
-                this._emitter.off(...args);
-                return this;
-            }
-            once(...args) {
-                this._emitter.once(...args);
-                return this;
-            }
-            getMongoClientConnectionOptions() {
-                // `notifyDeviceFlow` is a function which cannot be serialized for inclusion
-                // in the shell, `signal` is an abortSignal, and `allowedFlows` is turned
-                // into a function by the connection code.
-                return (0, lodash_1.omit)(this._mongoClientConnectionOptions, 'options.oidc.notifyDeviceFlow', 'options.oidc.signal', 'options.oidc.allowedFlows', 'options.oidc.customFetch', 'options.oidc.customHttpOptions');
-            }
-            getConnectionOptions() {
-                return this._connectionOptions;
-            }
-            getConnectionString() {
-                return new mongodb_connection_string_url_1.default(this._connectionOptions.connectionString);
-            }
-            setCSFLEEnabled(enabled) {
-                this._logger.info((0, logger_1.mongoLogId)(1_001_000_117), 'Setting CSFLE mode', {
-                    enabled,
-                });
-                this._useCRUDClient = enabled;
-            }
-            getCSFLEMode() {
-                if (this._crudClient && (0, instance_detail_helper_2.checkIsCSFLEConnection)(this._crudClient)) {
-                    if (this._useCRUDClient) {
-                        return 'enabled';
-                    }
-                    else {
-                        return 'disabled';
-                    }
-                }
-                else {
-                    return 'unavailable';
-                }
-            }
-            async collectionStats(databaseName, collectionName, collectionType) {
-                const ns = `${databaseName}.${collectionName}`;
-                try {
-                    const coll = this._collection(ns, 'CRUD');
-                    // Build the aggregation pipeline dynamically based on collection type
-                    const groupStage = {
-                        _id: null,
-                        capped: { $first: '$storageStats.capped' },
-                        count: { $sum: '$storageStats.count' },
-                        size: { $sum: { $toDouble: '$storageStats.size' } },
-                        storageSize: {
-                            $sum: { $toDouble: '$storageStats.storageSize' },
-                        },
-                        totalIndexSize: {
-                            $sum: { $toDouble: '$storageStats.totalIndexSize' },
-                        },
-                        freeStorageSize: {
-                            $sum: { $toDouble: '$storageStats.freeStorageSize' },
-                        },
-                        unscaledCollSize: {
-                            $sum: {
-                                $multiply: [
-                                    { $toDouble: '$storageStats.avgObjSize' },
-                                    { $toDouble: '$storageStats.count' },
-                                ],
-                            },
-                        },
-                        nindexes: { $max: '$storageStats.nindexes' },
+                // Only extract bucket statistics for time series collections
+                if (collectionType === 'timeseries') {
+                    groupStage.timeseriesBucketCount = {
+                        $first: '$storageStats.timeseries.bucketCount',
                     };
-                    // Only extract bucket statistics for time series collections
-                    if (collectionType === 'timeseries') {
-                        groupStage.timeseriesBucketCount = {
-                            $first: '$storageStats.timeseries.bucketCount',
-                        };
-                        groupStage.timeseriesAvgBucketSize = {
-                            $first: '$storageStats.timeseries.avgBucketSize',
-                        };
-                    }
-                    const addFieldsStage = {
-                        // `avgObjSize` is the average of per-shard `avgObjSize` weighted by `count`
-                        __proto__: null,
-                        avgObjSize: {
-                            $cond: {
-                                if: { $ne: ['$count', 0] },
-                                then: {
-                                    $divide: ['$unscaledCollSize', { $toDouble: '$count' }],
-                                },
-                                else: 0,
+                    groupStage.timeseriesAvgBucketSize = {
+                        $first: '$storageStats.timeseries.avgBucketSize',
+                    };
+                }
+                const addFieldsStage = {
+                    // `avgObjSize` is the average of per-shard `avgObjSize` weighted by `count`
+                    __proto__: null,
+                    avgObjSize: {
+                        $cond: {
+                            if: { $ne: ['$count', 0] },
+                            then: {
+                                $divide: ['$unscaledCollSize', { $toDouble: '$count' }],
                             },
+                            else: 0,
                         },
-                    };
-                    // Only calculate bucket stats for time series collections
-                    if (collectionType === 'timeseries') {
-                        addFieldsStage.bucket_count = '$timeseriesBucketCount';
-                        addFieldsStage.avg_bucket_size = '$timeseriesAvgBucketSize';
-                    }
-                    const collStats = await coll
-                        .aggregate([
-                        { $collStats: { storageStats: {} } },
-                        { $group: groupStage },
-                        { $addFields: addFieldsStage },
-                    ], { enableUtf8Validation: false })
-                        .toArray();
-                    if (!collStats || collStats[0] === undefined) {
-                        throw new Error(`Error running $collStats aggregation stage on ${ns}`);
-                    }
-                    collStats[0].ns = ns;
-                    return this._buildCollectionStats(databaseName, collectionName, collStats[0]);
+                    },
+                };
+                // Only calculate bucket stats for time series collections
+                if (collectionType === 'timeseries') {
+                    addFieldsStage.bucket_count = '$timeseriesBucketCount';
+                    addFieldsStage.avg_bucket_size = '$timeseriesAvgBucketSize';
                 }
-                catch (error) {
-                    const message = error.message;
-                    if (
-                    // We ignore errors for fetching collStats when requesting on an
-                    // unsupported collection type: either a view or a ADF
-                    message.includes('not valid for Data Lake') ||
-                        message.includes('is a view, not a collection') ||
-                        // When trying to fetch collectionStats for a collection whose db
-                        // does not exist or the collection itself does not exist, the
-                        // server throws an error. This happens because we show collections
-                        // to the user from their privileges.
-                        message.includes(`Database [${databaseName}] not found`) ||
-                        message.includes(`Collection [${databaseName}.${collectionName}] not found`)) {
-                        return this._buildCollectionStats(databaseName, collectionName, {});
-                    }
-                    throw error;
+                const collStats = await coll
+                    .aggregate([
+                    { $collStats: { storageStats: {} } },
+                    { $group: groupStage },
+                    { $addFields: addFieldsStage },
+                ], { enableUtf8Validation: false })
+                    .toArray();
+                if (!collStats || collStats[0] === undefined) {
+                    throw new Error(`Error running $collStats aggregation stage on ${ns}`);
                 }
+                collStats[0].ns = ns;
+                return this._buildCollectionStats(databaseName, collectionName, collStats[0]);
             }
-            async collectionInfo(dbName, collName) {
-                const [collInfo] = await this._listCollections(dbName, { name: collName });
-                return ((0, instance_detail_helper_2.adaptCollectionInfo)({
-                    db: dbName,
-                    ...collInfo,
-                }) ?? null);
-            }
-            async killOp(id, comment) {
-                const db = this._database('admin', 'META');
-                return (0, run_command_1.runCommand)(db, { killOp: 1, id, comment }, { enableUtf8Validation: false });
-            }
-            isWritable() {
-                return this._isWritable;
-            }
-            isMongos() {
-                return this.getCurrentTopologyType() === 'Sharded';
+            catch (error) {
+                const message = error.message;
+                if (
+                // We ignore errors for fetching collStats when requesting on an
+                // unsupported collection type: either a view or a ADF
+                message.includes('not valid for Data Lake') ||
+                    message.includes('is a view, not a collection') ||
+                    // When trying to fetch collectionStats for a collection whose db
+                    // does not exist or the collection itself does not exist, the
+                    // server throws an error. This happens because we show collections
+                    // to the user from their privileges.
+                    message.includes(`Database [${databaseName}] not found`) ||
+                    message.includes(`Collection [${databaseName}.${collectionName}] not found`)) {
+                    return this._buildCollectionStats(databaseName, collectionName, {});
+                }
+                throw error;
             }
-            getCurrentTopologyType() {
-                return this.getLastSeenTopology()?.type ?? 'Unknown';
+        }
+        async collectionInfo(dbName, collName) {
+            const [collInfo] = await this._listCollections(dbName, { name: collName });
+            return ((0, instance_detail_helper_2.adaptCollectionInfo)({
+                db: dbName,
+                ...collInfo,
+            }) ?? null);
+        }
+        async killOp(id, comment) {
+            const db = this._database('admin', 'META');
+            return (0, run_command_1.runCommand)(db, { killOp: 1, id, comment }, { enableUtf8Validation: false });
+        }
+        isWritable() {
+            return this._isWritable;
+        }
+        isMongos() {
+            return this.getCurrentTopologyType() === 'Sharded';
+        }
+        getCurrentTopologyType() {
+            return this.getLastSeenTopology()?.type ?? 'Unknown';
+        }
+        async _connectionStatus() {
+            const adminDb = this._database('admin', 'META');
+            return await (0, run_command_1.runCommand)(adminDb, {
+                connectionStatus: 1,
+                showPrivileges: true,
+            }, { enableUtf8Validation: false });
+        }
+        async _getPrivilegesOrFallback(privileges = null) {
+            if (privileges) {
+                return privileges;
             }
-            async _connectionStatus() {
-                const adminDb = this._database('admin', 'META');
-                return await (0, run_command_1.runCommand)(adminDb, {
-                    connectionStatus: 1,
-                    showPrivileges: true,
-                }, { enableUtf8Validation: false });
+            const { authInfo: { authenticatedUserPrivileges }, } = await this._connectionStatus();
+            return authenticatedUserPrivileges;
+        }
+        async _getRolesOrFallback(roles = null) {
+            if (roles) {
+                return roles;
             }
-            async _getPrivilegesOrFallback(privileges = null) {
-                if (privileges) {
-                    return privileges;
+            const { authInfo: { authenticatedUserRoles }, } = await this._connectionStatus();
+            return authenticatedUserRoles;
+        }
+        async _listCollections(databaseName, filter = {}, { nameOnly } = {}) {
+            try {
+                const cursor = this._database(databaseName, 'CRUD').listCollections(filter, {
+                    nameOnly,
+                    ...maybeOverrideReadPreference(this.isMongos(), this._crudClient?.readPreference),
+                });
+                // Iterate instead of using .toArray() so we can emit
+                // collection info update events as they come in.
+                const results = [];
+                for await (const result of cursor) {
+                    if (!nameOnly) {
+                        this._csfleCollectionTracker?.updateCollectionInfo(`${databaseName}.${result.name}`, result);
+                    }
+                    results.push(result);
                 }
-                const { authInfo: { authenticatedUserPrivileges }, } = await this._connectionStatus();
-                return authenticatedUserPrivileges;
+                return results;
+            }
+            catch (err) {
+                // Currently Compass should not fail if listCollections failed for
+                // any possible reason to preserve current behavior. We probably
+                // want this to check at least that what we got back is a server
+                // error and not a weird runtime issue on our side that can be
+                // swallowed in this case, ideally we know exactly what server
+                // errors we want to handle here and only avoid throwing in these
+                // cases
+                //
+                // TODO: https://jira.mongodb.org/browse/COMPASS-5275
+                this._logger.warn((0, logger_1.mongoLogId)(1_001_000_099), 'Failed to run listCollections', { message: err.message });
+                return [];
             }
-            async _getRolesOrFallback(roles = null) {
-                if (roles) {
-                    return roles;
+        }
+        async listCollections(databaseName, filter = {}, { nameOnly, fetchNamespacesFromPrivileges = true, privileges = null, } = {}) {
+            const listCollections = async () => {
+                const colls = await this._listCollections(databaseName, filter, {
+                    nameOnly,
+                });
+                return colls.map((coll) => ({
+                    inferred_from_privileges: false,
+                    ...coll,
+                }));
+            };
+            const getCollectionsFromPrivileges = async () => {
+                if (!fetchNamespacesFromPrivileges) {
+                    return [];
                 }
-                const { authInfo: { authenticatedUserRoles }, } = await this._connectionStatus();
-                return authenticatedUserRoles;
-            }
-            async _listCollections(databaseName, filter = {}, { nameOnly } = {}) {
+                const databases = (0, instance_detail_helper_2.getPrivilegesByDatabaseAndCollection)(await this._getPrivilegesOrFallback(privileges), ['find']);
+                return Object.keys(
+                // Privileges might not have a database we are looking for
+                databases[databaseName] || {})
+                    .filter(
+                // Privileges can have collection name '' that indicates
+                // privileges on all collections in the database, we don't want
+                // those registered as "real" collection names
+                Boolean)
+                    .map((name) => ({ name, inferred_from_privileges: true }));
+            };
+            const [listedCollections, collectionsFromPrivileges] = await Promise.all([
+                listCollections(),
+                // If the filter is not empty, we can't meaningfully derive collections
+                // from privileges and filter them as the criteria might include any key
+                // from the listCollections result object and there is no such info in
+                // privileges. Because of that we are ignoring privileges completely if
+                // listCollections was called with a filter.
+                isEmptyObject(filter) ? getCollectionsFromPrivileges() : [],
+            ]);
+            const collections = uniqueBy(
+            // NB: Order is important, we want listed collections to take precedence
+            // if they were fetched successfully
+            [...collectionsFromPrivileges, ...listedCollections], 'name').map(({ inferred_from_privileges, ...coll }) => ({
+                inferred_from_privileges,
+                ...(0, instance_detail_helper_2.adaptCollectionInfo)({ db: databaseName, ...coll }),
+            }));
+            return collections;
+        }
+        async listDatabases({ nameOnly, fetchNamespacesFromPrivileges = true, privileges = null, roles = null, } = {}) {
+            const adminDb = this._database('admin', 'CRUD');
+            const listDatabases = async () => {
                 try {
-                    const cursor = this._database(databaseName, 'CRUD').listCollections(filter, {
+                    const { databases } = await (0, run_command_1.runCommand)(adminDb, {
+                        listDatabases: 1,
                         nameOnly,
+                    }, {
+                        enableUtf8Validation: false,
                         ...maybeOverrideReadPreference(this.isMongos(), this._crudClient?.readPreference),
                     });
-                    // Iterate instead of using .toArray() so we can emit
-                    // collection info update events as they come in.
-                    const results = [];
-                    for await (const result of cursor) {
-                        if (!nameOnly) {
-                            this._csfleCollectionTracker?.updateCollectionInfo(`${databaseName}.${result.name}`, result);
-                        }
-                        results.push(result);
-                    }
-                    return results;
+                    return databases.map((x) => ({
+                        ...x,
+                        inferred_from_privileges: false,
+                    }));
                 }
                 catch (err) {
-                    // Currently Compass should not fail if listCollections failed for
-                    // any possible reason to preserve current behavior. We probably
-                    // want this to check at least that what we got back is a server
-                    // error and not a weird runtime issue on our side that can be
-                    // swallowed in this case, ideally we know exactly what server
-                    // errors we want to handle here and only avoid throwing in these
-                    // cases
+                    // Currently Compass should not fail if listDatabase failed for any
+                    // possible reason to preserve current behavior. We probably want this
+                    // to check at least that what we got back is a server error and not a
+                    // weird runtime issue on our side that can be swallowed in this case,
+                    // ideally we know exactly what server errors we want to handle here
+                    // and only avoid throwing in these cases
                     //
                     // TODO: https://jira.mongodb.org/browse/COMPASS-5275
-                    this._logger.warn((0, logger_1.mongoLogId)(1_001_000_099), 'Failed to run listCollections', { message: err.message });
+                    this._logger.warn((0, logger_1.mongoLogId)(1_001_000_098), 'Failed to run listDatabases', { message: err.message });
                     return [];
                 }
-            }
-            async listCollections(databaseName, filter = {}, { nameOnly, fetchNamespacesFromPrivileges = true, privileges = null, } = {}) {
-                const listCollections = async () => {
-                    const colls = await this._listCollections(databaseName, filter, {
-                        nameOnly,
-                    });
-                    return colls.map((coll) => ({
-                        inferred_from_privileges: false,
-                        ...coll,
-                    }));
-                };
-                const getCollectionsFromPrivileges = async () => {
-                    if (!fetchNamespacesFromPrivileges) {
-                        return [];
-                    }
-                    const databases = (0, instance_detail_helper_2.getPrivilegesByDatabaseAndCollection)(await this._getPrivilegesOrFallback(privileges), ['find']);
-                    return Object.keys(
-                    // Privileges might not have a database we are looking for
-                    databases[databaseName] || {})
-                        .filter(
-                    // Privileges can have collection name '' that indicates
-                    // privileges on all collections in the database, we don't want
-                    // those registered as "real" collection names
-                    Boolean)
-                        .map((name) => ({ name, inferred_from_privileges: true }));
-                };
-                const [listedCollections, collectionsFromPrivileges] = await Promise.all([
-                    listCollections(),
-                    // If the filter is not empty, we can't meaningfully derive collections
-                    // from privileges and filter them as the criteria might include any key
-                    // from the listCollections result object and there is no such info in
-                    // privileges. Because of that we are ignoring privileges completely if
-                    // listCollections was called with a filter.
-                    isEmptyObject(filter) ? getCollectionsFromPrivileges() : [],
-                ]);
-                const collections = uniqueBy(
-                // NB: Order is important, we want listed collections to take precedence
-                // if they were fetched successfully
-                [...collectionsFromPrivileges, ...listedCollections], 'name').map(({ inferred_from_privileges, ...coll }) => ({
-                    inferred_from_privileges,
-                    ...(0, instance_detail_helper_2.adaptCollectionInfo)({ db: databaseName, ...coll }),
+            };
+            const getDatabasesFromPrivileges = async () => {
+                if (!fetchNamespacesFromPrivileges) {
+                    return [];
+                }
+                const databases = (0, instance_detail_helper_2.getPrivilegesByDatabaseAndCollection)(await this._getPrivilegesOrFallback(privileges), ['find']);
+                return Object.keys(databases)
+                    .filter(
+                // For the roles created in admin database, the database name
+                // can be '' meaning that it applies to all databases. We can't
+                // meaningfully handle this in the UI so we are filtering these
+                // out
+                Boolean)
+                    .map((name) => ({ name, inferred_from_privileges: true }));
+            };
+            const getDatabasesFromRoles = async () => {
+                const databases = (0, instance_detail_helper_2.getDatabasesByRoles)(await this._getRolesOrFallback(roles), 
+                // https://jira.mongodb.org/browse/HELP-32199
+                // Atlas shared tier MongoDB server version v5+ does not return
+                // `authenticatedUserPrivileges` as part of the `connectionStatus`.
+                // As a workaround we show the databases the user has
+                // certain general built-in roles for.
+                // This does not cover custom user roles which can
+                // have custom privileges that we can't currently fetch.
+                ['read', 'readWrite', 'dbAdmin', 'dbOwner']);
+                return databases.map((name) => ({
+                    name,
+                    inferred_from_privileges: true,
                 }));
-                return collections;
-            }
-            async listDatabases({ nameOnly, fetchNamespacesFromPrivileges = true, privileges = null, roles = null, } = {}) {
-                const adminDb = this._database('admin', 'CRUD');
-                const listDatabases = async () => {
-                    try {
-                        const { databases } = await (0, run_command_1.runCommand)(adminDb, {
-                            listDatabases: 1,
-                            nameOnly,
-                        }, {
-                            enableUtf8Validation: false,
-                            ...maybeOverrideReadPreference(this.isMongos(), this._crudClient?.readPreference),
-                        });
-                        return databases.map((x) => ({
-                            ...x,
-                            inferred_from_privileges: false,
-                        }));
-                    }
-                    catch (err) {
-                        // Currently Compass should not fail if listDatabase failed for any
-                        // possible reason to preserve current behavior. We probably want this
-                        // to check at least that what we got back is a server error and not a
-                        // weird runtime issue on our side that can be swallowed in this case,
-                        // ideally we know exactly what server errors we want to handle here
-                        // and only avoid throwing in these cases
-                        //
-                        // TODO: https://jira.mongodb.org/browse/COMPASS-5275
-                        this._logger.warn((0, logger_1.mongoLogId)(1_001_000_098), 'Failed to run listDatabases', { message: err.message });
-                        return [];
-                    }
-                };
-                const getDatabasesFromPrivileges = async () => {
-                    if (!fetchNamespacesFromPrivileges) {
-                        return [];
-                    }
-                    const databases = (0, instance_detail_helper_2.getPrivilegesByDatabaseAndCollection)(await this._getPrivilegesOrFallback(privileges), ['find']);
-                    return Object.keys(databases)
-                        .filter(
-                    // For the roles created in admin database, the database name
-                    // can be '' meaning that it applies to all databases. We can't
-                    // meaningfully handle this in the UI so we are filtering these
-                    // out
-                    Boolean)
-                        .map((name) => ({ name, inferred_from_privileges: true }));
-                };
-                const getDatabasesFromRoles = async () => {
-                    const databases = (0, instance_detail_helper_2.getDatabasesByRoles)(await this._getRolesOrFallback(roles), 
-                    // https://jira.mongodb.org/browse/HELP-32199
-                    // Atlas shared tier MongoDB server version v5+ does not return
-                    // `authenticatedUserPrivileges` as part of the `connectionStatus`.
-                    // As a workaround we show the databases the user has
-                    // certain general built-in roles for.
-                    // This does not cover custom user roles which can
-                    // have custom privileges that we can't currently fetch.
-                    ['read', 'readWrite', 'dbAdmin', 'dbOwner']);
-                    return databases.map((name) => ({
-                        name,
-                        inferred_from_privileges: true,
-                    }));
+            };
+            const [listedDatabases, databasesFromPrivileges, databasesFromRoles] = await Promise.all([
+                listDatabases(),
+                getDatabasesFromPrivileges(),
+                getDatabasesFromRoles(),
+            ]);
+            const databases = uniqueBy(
+            // NB: Order is important, we want listed collections to take precedence
+            // if they were fetched successfully
+            [...databasesFromRoles, ...databasesFromPrivileges, ...listedDatabases], 'name').map(({ name, inferred_from_privileges, ...db }) => {
+                return {
+                    _id: name,
+                    name,
+                    inferred_from_privileges,
+                    ...(0, instance_detail_helper_2.adaptDatabaseInfo)(db),
                 };
-                const [listedDatabases, databasesFromPrivileges, databasesFromRoles] = await Promise.all([
-                    listDatabases(),
-                    getDatabasesFromPrivileges(),
-                    getDatabasesFromRoles(),
-                ]);
-                const databases = uniqueBy(
-                // NB: Order is important, we want listed collections to take precedence
-                // if they were fetched successfully
-                [...databasesFromRoles, ...databasesFromPrivileges, ...listedDatabases], 'name').map(({ name, inferred_from_privileges, ...db }) => {
-                    return {
-                        _id: name,
-                        name,
-                        inferred_from_privileges,
-                        ...(0, instance_detail_helper_2.adaptDatabaseInfo)(db),
-                    };
-                });
-                return databases;
-            }
-            addReauthenticationHandler(handler) {
-                this._reauthenticationHandlers.add(handler);
+            });
+            return databases;
+        }
+        addReauthenticationHandler(handler) {
+            this._reauthenticationHandlers.add(handler);
+        }
+        async _requestReauthenticationFromUser() {
+            this._logger.info((0, logger_1.mongoLogId)(1_001_000_194), 'Requesting re-authentication from user');
+            let threw = true;
+            try {
+                for (const handler of this._reauthenticationHandlers)
+                    await handler();
+                threw = false;
             }
-            async _requestReauthenticationFromUser() {
-                this._logger.info((0, logger_1.mongoLogId)(1_001_000_194), 'Requesting re-authentication from user');
-                let threw = true;
-                try {
-                    for (const handler of this._reauthenticationHandlers)
-                        await handler();
-                    threw = false;
-                }
-                finally {
-                    this._logger.info((0, logger_1.mongoLogId)(1_001_000_193), 'Completed re-authentication request', {
-                        wantsReauth: !threw,
-                    });
-                }
+            finally {
+                this._logger.info((0, logger_1.mongoLogId)(1_001_000_193), 'Completed re-authentication request', {
+                    wantsReauth: !threw,
+                });
             }
-            async connect({ signal, productName, productDocsLink, } = {}) {
-                if (this._metadataClient) {
-                    (0, logger_1.debug)('already connected');
-                    return;
-                }
-                if (this._isConnecting) {
-                    (0, logger_1.debug)('connect method called more than once');
-                    return;
-                }
-                (0, logger_1.debug)('connecting...');
-                this._isConnecting = true;
-                const clusterName = this._connectionOptions.lookup?.().clusterName;
-                this._logger.info((0, logger_1.mongoLogId)(1_001_000_014), 'Connecting Started', {
+        }
+        async connect({ signal, productName, productDocsLink, } = {}) {
+            if (this._metadataClient) {
+                (0, logger_1.debug)('already connected');
+                return;
+            }
+            if (this._isConnecting) {
+                (0, logger_1.debug)('connect method called more than once');
+                return;
+            }
+            (0, logger_1.debug)('connecting...');
+            this._isConnecting = true;
+            const clusterName = this._connectionOptions.lookup?.().clusterName;
+            this._logger.info((0, logger_1.mongoLogId)(1_001_000_014), 'Connecting Started', {
+                connectionId: this._id,
+                url: (0, redact_1.redactConnectionString)(this._connectionOptions.connectionString),
+                csfle: this._csfleLogInformation(this._connectionOptions.fleOptions),
+                ...(clusterName && { clusterName }),
+            });
+            try {
+                const [metadataClient, crudClient, tunnel, state, connectionOptions] = await (0, connect_mongo_client_1.connectMongoClientDataService)({
+                    connectionOptions: this._connectionOptions,
+                    proxyOptions: this._proxyOptions,
+                    setupListeners: this._setupListeners.bind(this),
+                    signal,
+                    logger: this._unboundLogger,
+                    productName,
+                    productDocsLink,
+                    reauthenticationHandler: this._requestReauthenticationFromUser.bind(this),
+                });
+                const attr = {
                     connectionId: this._id,
-                    url: (0, redact_1.redactConnectionString)(this._connectionOptions.connectionString),
-                    csfle: this._csfleLogInformation(this._connectionOptions.fleOptions),
+                    isWritable: this.isWritable(),
+                    isMongos: this.isMongos(),
                     ...(clusterName && { clusterName }),
+                };
+                this._logger.info((0, logger_1.mongoLogId)(1_001_000_015), 'Connecting Succeeded', attr);
+                (0, logger_1.debug)('connected!', attr);
+                state.oidcPlugin.logger.on('mongodb-oidc-plugin:state-updated', () => {
+                    this._emitter.emit('connectionInfoSecretsChanged');
                 });
-                try {
-                    const [metadataClient, crudClient, tunnel, state, connectionOptions] = await (0, connect_mongo_client_1.connectMongoClientDataService)({
-                        connectionOptions: this._connectionOptions,
-                        proxyOptions: this._proxyOptions,
-                        setupListeners: this._setupListeners.bind(this),
-                        signal,
-                        logger: this._unboundLogger,
-                        productName,
-                        productDocsLink,
-                        reauthenticationHandler: this._requestReauthenticationFromUser.bind(this),
-                    });
-                    const attr = {
-                        connectionId: this._id,
-                        isWritable: this.isWritable(),
-                        isMongos: this.isMongos(),
-                        ...(clusterName && { clusterName }),
-                    };
-                    this._logger.info((0, logger_1.mongoLogId)(1_001_000_015), 'Connecting Succeeded', attr);
-                    (0, logger_1.debug)('connected!', attr);
-                    state.oidcPlugin.logger.on('mongodb-oidc-plugin:state-updated', () => {
-                        this._emitter.emit('connectionInfoSecretsChanged');
-                    });
-                    state.oidcPlugin.logger.on('mongodb-oidc-plugin:auth-failed', ({ error }) => {
-                        this._emitter.emit('oidcAuthFailed', error);
-                    });
-                    this._metadataClient = metadataClient;
-                    this._crudClient = crudClient;
-                    this._tunnel = tunnel;
-                    this._state = state;
-                    this._mongoClientConnectionOptions = connectionOptions;
-                    this._csfleCollectionTracker = new csfle_collection_tracker_1.CSFLECollectionTrackerImpl(this, this._crudClient);
-                }
-                catch (error) {
-                    this._logger.info((0, logger_1.mongoLogId)(1_001_000_359), 'Connecting Failed', {
-                        connectionId: this._id,
-                        error: error && typeof error === 'object' && 'message' in error
-                            ? error?.message
-                            : 'unknown error',
-                        ...(clusterName && { clusterName }),
-                    });
-                    throw error;
-                }
-                finally {
-                    this._isConnecting = false;
-                }
-            }
-            estimatedCount(ns, options = {}, executionOptions) {
-                const maxTimeMS = options.maxTimeMS ?? 500;
-                return this._cancellableOperation(async (session) => {
-                    return this._collection(ns, 'CRUD').estimatedDocumentCount({
-                        ...options,
-                        maxTimeMS,
-                        session,
-                    });
-                }, (session) => session.endSession(), executionOptions?.abortSignal);
-            }
-            count(ns, filter, options = {}, executionOptions) {
-                return this._cancellableOperation(async (session) => {
-                    return this._collection(ns, 'CRUD').countDocuments(filter, {
-                        ...this._getOptionsWithFallbackReadPreference(options, executionOptions),
-                        session,
-                    });
-                }, (session) => session.endSession(), executionOptions?.abortSignal);
-            }
-            async createCollection(ns, options) {
-                const collectionName = this._collectionName(ns);
-                const db = this._database(ns, 'CRUD');
-                return await db.createCollection(collectionName, options);
-            }
-            async createIndex(ns, spec, options) {
-                const coll = this._collection(ns, 'CRUD');
-                return await coll.createIndex(spec, options);
-            }
-            async deleteOne(ns, filter, options) {
-                const coll = this._collection(ns, 'CRUD');
-                return await coll.deleteOne(filter, options);
+                state.oidcPlugin.logger.on('mongodb-oidc-plugin:auth-failed', ({ error }) => {
+                    this._emitter.emit('oidcAuthFailed', error);
+                });
+                this._metadataClient = metadataClient;
+                this._crudClient = crudClient;
+                this._tunnel = tunnel;
+                this._state = state;
+                this._mongoClientConnectionOptions = connectionOptions;
+                this._csfleCollectionTracker = new csfle_collection_tracker_1.CSFLECollectionTrackerImpl(this, this._crudClient);
             }
-            async deleteMany(ns, filter, options) {
-                const coll = this._collection(ns, 'CRUD');
-                return await coll.deleteMany(filter, options);
+            catch (error) {
+                this._logger.info((0, logger_1.mongoLogId)(1_001_000_359), 'Connecting Failed', {
+                    connectionId: this._id,
+                    error: error && typeof error === 'object' && 'message' in error
+                        ? error?.message
+                        : 'unknown error',
+                    ...(clusterName && { clusterName }),
+                });
+                throw error;
             }
-            async updateMany(ns, filter, update, options) {
-                const coll = this._collection(ns, 'CRUD');
-                return await coll.updateMany(filter, update, options);
+            finally {
+                this._isConnecting = false;
             }
-            async disconnect() {
-                this._logger.info((0, logger_1.mongoLogId)(1_001_000_016), 'Disconnecting');
-                try {
-                    await Promise.all([
-                        this._metadataClient
+        }
+        estimatedCount(ns, options = {}, executionOptions) {
+            const maxTimeMS = options.maxTimeMS ?? 500;
+            return this._cancellableOperation(async (session) => {
+                return this._collection(ns, 'CRUD').estimatedDocumentCount({
+                    ...options,
+                    maxTimeMS,
+                    session,
+                });
+            }, (session) => session.endSession(), executionOptions?.abortSignal);
+        }
+        count(ns, filter, options = {}, executionOptions) {
+            return this._cancellableOperation(async (session) => {
+                return this._collection(ns, 'CRUD').countDocuments(filter, {
+                    ...this._getOptionsWithFallbackReadPreference(options, executionOptions),
+                    session,
+                });
+            }, (session) => session.endSession(), executionOptions?.abortSignal);
+        }
+        async createCollection(ns, options) {
+            const collectionName = this._collectionName(ns);
+            const db = this._database(ns, 'CRUD');
+            return await db.createCollection(collectionName, options);
+        }
+        async createIndex(ns, spec, options) {
+            const coll = this._collection(ns, 'CRUD');
+            return await coll.createIndex(spec, options);
+        }
+        async deleteOne(ns, filter, options) {
+            const coll = this._collection(ns, 'CRUD');
+            return await coll.deleteOne(filter, options);
+        }
+        async deleteMany(ns, filter, options) {
+            const coll = this._collection(ns, 'CRUD');
+            return await coll.deleteMany(filter, options);
+        }
+        async updateMany(ns, filter, update, options) {
+            const coll = this._collection(ns, 'CRUD');
+            return await coll.updateMany(filter, update, options);
+        }
+        async disconnect() {
+            this._logger.info((0, logger_1.mongoLogId)(1_001_000_016), 'Disconnecting');
+            try {
+                await Promise.all([
+                    this._metadataClient
+                        ?.close(true)
+                        .catch((err) => (0, logger_1.debug)('failed to close MongoClient', err)),
+                    this._crudClient !== this._metadataClient &&
+                        this._crudClient
                             ?.close(true)
                             .catch((err) => (0, logger_1.debug)('failed to close MongoClient', err)),
-                        this._crudClient !== this._metadataClient &&
-                            this._crudClient
-                                ?.close(true)
-                                .catch((err) => (0, logger_1.debug)('failed to close MongoClient', err)),
-                        this._tunnel
-                            ?.close()
-                            .catch((err) => (0, logger_1.debug)('failed to close tunnel', err)),
-                        this._state
-                            ?.destroy()
-                            .catch((err) => (0, logger_1.debug)('failed to destroy DevtoolsConnectionState', err)),
-                    ]);
-                }
-                finally {
-                    this._cleanup();
-                    this._logger.info((0, logger_1.mongoLogId)(1_001_000_017), 'Fully closed');
-                }
-            }
-            async dropCollection(ns) {
-                const db = this._database(ns, 'CRUD');
-                const collName = this._collectionName(ns);
-                const coll = db.collection(collName);
-                let result = null;
-                try {
-                    [result] = await db
-                        .listCollections({ name: collName }, { nameOnly: false })
-                        .toArray();
-                }
-                catch {
-                    // ignore
-                }
-                const options = {};
-                const encryptedFieldsInfo = result?.options?.encryptedFields;
-                if (encryptedFieldsInfo) {
-                    options.encryptedFields = encryptedFieldsInfo;
-                }
-                return await coll.drop(options);
-            }
-            renameCollection(ns, newCollectionName) {
-                const db = this._database(ns, 'META');
-                return db.renameCollection(this._collectionName(ns), newCollectionName);
-            }
-            async dropDatabase(name) {
-                const db = this._database(name, 'CRUD');
-                return await db.dropDatabase();
-            }
-            async dropIndex(ns, name) {
-                const coll = this._collection(ns, 'CRUD');
-                return await coll.dropIndex(name);
-            }
-            async isListSearchIndexesSupported(ns) {
-                try {
-                    await this.getSearchIndexes(ns);
-                }
-                catch {
-                    return false;
-                }
-                return true;
-            }
-            async getSearchIndexes(ns) {
-                const coll = this._collection(ns, 'CRUD');
-                const cursor = coll.listSearchIndexes();
-                const indexes = await cursor.toArray();
-                void cursor.close();
-                return indexes;
-            }
-            async createSearchIndex(ns, description) {
-                const coll = this._collection(ns, 'CRUD');
-                return coll.createSearchIndex(description);
-            }
-            async updateSearchIndex(ns, name, definition) {
-                const coll = this._collection(ns, 'CRUD');
-                return coll.updateSearchIndex(name, definition);
-            }
-            async dropSearchIndex(ns, name) {
-                const coll = this._collection(ns, 'CRUD');
-                return coll.dropSearchIndex(name);
-            }
-            aggregateCursor(ns, pipeline, options = {}) {
-                return this._collection(ns, 'CRUD').aggregate(pipeline, options);
-            }
-            // @ts-expect-error generic in the method trips up TS here resulting in
-            // Promise<unknown> is not assignable to Promise<Document[]>
-            aggregate(ns, pipeline, options = {}, executionOptions) {
-                let cursor;
-                return this._cancellableOperation(async (session) => {
-                    cursor = this._collection(ns, 'CRUD').aggregate(pipeline, {
-                        ...options,
-                        session,
-                    });
-                    const results = await cursor.toArray();
-                    void cursor.close();
-                    return results;
-                }, () => cursor?.close(), executionOptions?.abortSignal);
-            }
-            find(ns, filter, options = {}, executionOptions) {
-                let cursor;
-                return this._cancellableOperation(async (session) => {
-                    cursor = this._collection(ns, 'CRUD').find(filter, {
-                        ...options,
-                        session,
-                    });
-                    const results = await cursor.toArray();
-                    void cursor.close();
-                    return results;
-                }, () => cursor?.close(), executionOptions?.abortSignal);
-            }
-            findCursor(ns, filter, options = {}) {
-                return this._collection(ns, 'CRUD').find(filter, options);
+                    this._tunnel
+                        ?.close()
+                        .catch((err) => (0, logger_1.debug)('failed to close tunnel', err)),
+                    this._state
+                        ?.destroy()
+                        .catch((err) => (0, logger_1.debug)('failed to destroy DevtoolsConnectionState', err)),
+                ]);
             }
-            async findOneAndReplace(ns, filter, replacement, options) {
-                const coll = this._collection(ns, 'CRUD');
-                return await coll.findOneAndReplace(filter, replacement, options);
+            finally {
+                this._cleanup();
+                this._logger.info((0, logger_1.mongoLogId)(1_001_000_017), 'Fully closed');
             }
-            async findOneAndUpdate(ns, filter, update, options) {
-                const coll = this._collection(ns, 'CRUD');
-                return await coll.findOneAndUpdate(filter, update, options);
+        }
+        async dropCollection(ns) {
+            const db = this._database(ns, 'CRUD');
+            const collName = this._collectionName(ns);
+            const coll = db.collection(collName);
+            let result = null;
+            try {
+                [result] = await db
+                    .listCollections({ name: collName }, { nameOnly: false })
+                    .toArray();
             }
-            async updateOne(ns, filter, update, options) {
-                const coll = this._collection(ns, 'CRUD');
-                return await coll.updateOne(filter, update, options);
+            catch {
+                // ignore
             }
-            async replaceOne(ns, filter, replacement, options) {
-                const coll = this._collection(ns, 'CRUD');
-                return await coll.replaceOne(filter, replacement, options);
+            const options = {};
+            const encryptedFieldsInfo = result?.options?.encryptedFields;
+            if (encryptedFieldsInfo) {
+                options.encryptedFields = encryptedFieldsInfo;
             }
-            explainFind(ns, filter, options = {}, executionOptions) {
-                const verbosity = executionOptions?.explainVerbosity || mongodb_1.ExplainVerbosity.executionStats;
-                let cursor;
-                return this._cancellableOperation(async (session) => {
-                    cursor = this._collection(ns, 'CRUD').find(filter, {
-                        ...options,
-                        session,
-                    });
-                    const results = await cursor.explain({
-                        verbosity,
-                        maxTimeMS: executionOptions?.maxTimeMS,
-                    });
-                    void cursor.close();
-                    return results;
-                }, () => cursor?.close(), executionOptions?.abortSignal);
+            return await coll.drop(options);
+        }
+        renameCollection(ns, newCollectionName) {
+            const db = this._database(ns, 'META');
+            return db.renameCollection(this._collectionName(ns), newCollectionName);
+        }
+        async dropDatabase(name) {
+            const db = this._database(name, 'CRUD');
+            return await db.dropDatabase();
+        }
+        async dropIndex(ns, name) {
+            const coll = this._collection(ns, 'CRUD');
+            return await coll.dropIndex(name);
+        }
+        async isListSearchIndexesSupported(ns) {
+            try {
+                await this.getSearchIndexes(ns);
             }
-            explainAggregate(ns, pipeline, options, executionOptions) {
-                const verbosity = executionOptions?.explainVerbosity || mongodb_1.ExplainVerbosity.executionStats;
-                let cursor;
-                return this._cancellableOperation(async (session) => {
-                    cursor = this._collection(ns, 'CRUD').aggregate(pipeline, {
-                        ...options,
-                        session,
-                    });
-                    const results = await cursor.explain({
-                        verbosity,
-                        maxTimeMS: executionOptions?.maxTimeMS,
-                    });
-                    void cursor.close();
-                    return results;
-                }, () => cursor?.close(), executionOptions?.abortSignal);
+            catch {
+                return false;
             }
-            async _indexStats(ns) {
-                try {
-                    const stats = await this.aggregate(ns, [
-                        { $indexStats: {} },
-                        {
-                            $project: {
-                                name: 1,
-                                usageHost: '$host',
-                                usageCount: '$accesses.ops',
-                                usageSince: '$accesses.since',
-                            },
+            return true;
+        }
+        async getSearchIndexes(ns) {
+            const coll = this._collection(ns, 'CRUD');
+            const cursor = coll.listSearchIndexes();
+            const indexes = await cursor.toArray();
+            void cursor.close();
+            return indexes;
+        }
+        async createSearchIndex(ns, description) {
+            const coll = this._collection(ns, 'CRUD');
+            return coll.createSearchIndex(description);
+        }
+        async updateSearchIndex(ns, name, definition) {
+            const coll = this._collection(ns, 'CRUD');
+            return coll.updateSearchIndex(name, definition);
+        }
+        async dropSearchIndex(ns, name) {
+            const coll = this._collection(ns, 'CRUD');
+            return coll.dropSearchIndex(name);
+        }
+        aggregateCursor(ns, pipeline, options = {}) {
+            return this._collection(ns, 'CRUD').aggregate(pipeline, options);
+        }
+        // @ts-expect-error generic in the method trips up TS here resulting in
+        // Promise<unknown> is not assignable to Promise<Document[]>
+        aggregate(ns, pipeline, options = {}, executionOptions) {
+            let cursor;
+            return this._cancellableOperation(async (session) => {
+                cursor = this._collection(ns, 'CRUD').aggregate(pipeline, {
+                    ...options,
+                    session,
+                });
+                const results = await cursor.toArray();
+                void cursor.close();
+                return results;
+            }, () => cursor?.close(), executionOptions?.abortSignal);
+        }
+        find(ns, filter, options = {}, executionOptions) {
+            let cursor;
+            return this._cancellableOperation(async (session) => {
+                cursor = this._collection(ns, 'CRUD').find(filter, {
+                    ...options,
+                    session,
+                });
+                const results = await cursor.toArray();
+                void cursor.close();
+                return results;
+            }, () => cursor?.close(), executionOptions?.abortSignal);
+        }
+        findCursor(ns, filter, options = {}) {
+            return this._collection(ns, 'CRUD').find(filter, options);
+        }
+        async findOneAndReplace(ns, filter, replacement, options) {
+            const coll = this._collection(ns, 'CRUD');
+            return await coll.findOneAndReplace(filter, replacement, options);
+        }
+        async findOneAndUpdate(ns, filter, update, options) {
+            const coll = this._collection(ns, 'CRUD');
+            return await coll.findOneAndUpdate(filter, update, options);
+        }
+        async updateOne(ns, filter, update, options) {
+            const coll = this._collection(ns, 'CRUD');
+            return await coll.updateOne(filter, update, options);
+        }
+        async replaceOne(ns, filter, replacement, options) {
+            const coll = this._collection(ns, 'CRUD');
+            return await coll.replaceOne(filter, replacement, options);
+        }
+        explainFind(ns, filter, options = {}, executionOptions) {
+            const verbosity = executionOptions?.explainVerbosity || mongodb_1.ExplainVerbosity.executionStats;
+            let cursor;
+            return this._cancellableOperation(async (session) => {
+                cursor = this._collection(ns, 'CRUD').find(filter, {
+                    ...options,
+                    session,
+                });
+                const results = await cursor.explain({
+                    verbosity,
+                    maxTimeMS: executionOptions?.maxTimeMS,
+                });
+                void cursor.close();
+                return results;
+            }, () => cursor?.close(), executionOptions?.abortSignal);
+        }
+        explainAggregate(ns, pipeline, options, executionOptions) {
+            const verbosity = executionOptions?.explainVerbosity || mongodb_1.ExplainVerbosity.executionStats;
+            let cursor;
+            return this._cancellableOperation(async (session) => {
+                cursor = this._collection(ns, 'CRUD').aggregate(pipeline, {
+                    ...options,
+                    session,
+                });
+                const results = await cursor.explain({
+                    verbosity,
+                    maxTimeMS: executionOptions?.maxTimeMS,
+                });
+                void cursor.close();
+                return results;
+            }, () => cursor?.close(), executionOptions?.abortSignal);
+        }
+        async _indexStats(ns) {
+            try {
+                const stats = await this.aggregate(ns, [
+                    { $indexStats: {} },
+                    {
+                        $project: {
+                            name: 1,
+                            usageHost: '$host',
+                            usageCount: '$accesses.ops',
+                            usageSince: '$accesses.since',
                         },
-                    ]);
-                    return Object.fromEntries(stats.map((index) => {
-                        return [index.name, index];
-                    }));
-                }
-                catch (err) {
-                    if ((0, instance_detail_helper_1.isNotAuthorized)(err) || (0, instance_detail_helper_1.isNotSupportedPipelineStage)(err)) {
-                        return {};
-                    }
-                    throw err;
-                }
+                    },
+                ]);
+                return Object.fromEntries(stats.map((index) => {
+                    return [index.name, index];
+                }));
             }
-            async _indexSizes(ns) {
-                try {
-                    const coll = this._collection(ns, 'CRUD');
-                    const aggResult = (await coll
-                        .aggregate([
-                        { $collStats: { storageStats: {} } },
-                        {
-                            $project: {
-                                indexSizes: { $objectToArray: '$storageStats.indexSizes' },
-                            },
-                        },
-                        { $unwind: '$indexSizes' },
-                        {
-                            $group: {
-                                _id: '$indexSizes.k',
-                                size: { $sum: { $toDouble: '$indexSizes.v' } },
-                            },
-                        },
-                    ])
-                        .toArray());
-                    return Object.fromEntries(aggResult.map(({ _id, size }) => [_id, size]));
-                }
-                catch (err) {
-                    if ((0, instance_detail_helper_1.isNotAuthorized)(err) || (0, instance_detail_helper_1.isNotSupportedPipelineStage)(err)) {
-                        return {};
-                    }
-                    throw err;
+            catch (err) {
+                if ((0, instance_detail_helper_1.isNotAuthorized)(err) || (0, instance_detail_helper_1.isNotSupportedPipelineStage)(err)) {
+                    return {};
                 }
+                throw err;
             }
-            async _indexProgress(ns) {
-                const currentOp = { $currentOp: { allUsers: true, localOps: false } };
-                const pipeline = [
-                    // get all ops
-                    currentOp,
+        }
+        async _indexSizes(ns) {
+            try {
+                const coll = this._collection(ns, 'CRUD');
+                const aggResult = (await coll
+                    .aggregate([
+                    { $collStats: { storageStats: {} } },
                     {
-                        // filter for createIndexes commands
-                        $match: {
-                            ns,
-                            progress: { $type: 'object' },
-                            'command.createIndexes': { $exists: true },
+                        $project: {
+                            indexSizes: { $objectToArray: '$storageStats.indexSizes' },
                         },
                     },
+                    { $unwind: '$indexSizes' },
                     {
-                        // explode the "indexes" array for each createIndexes command
-                        $unwind: '$command.indexes',
-                    },
-                    {
-                        // group on index name
                         $group: {
-                            _id: '$command.indexes.name',
-                            progress: {
-                                $first: {
-                                    $cond: {
-                                        if: { $gt: ['$progress.total', 0] },
-                                        then: { $divide: ['$progress.done', '$progress.total'] },
-                                        else: 0,
-                                    },
+                            _id: '$indexSizes.k',
+                            size: { $sum: { $toDouble: '$indexSizes.v' } },
+                        },
+                    },
+                ])
+                    .toArray());
+                return Object.fromEntries(aggResult.map(({ _id, size }) => [_id, size]));
+            }
+            catch (err) {
+                if ((0, instance_detail_helper_1.isNotAuthorized)(err) || (0, instance_detail_helper_1.isNotSupportedPipelineStage)(err)) {
+                    return {};
+                }
+                throw err;
+            }
+        }
+        async _indexProgress(ns) {
+            const currentOp = { $currentOp: { allUsers: true, localOps: false } };
+            const pipeline = [
+                // get all ops
+                currentOp,
+                {
+                    // filter for createIndexes commands
+                    $match: {
+                        ns,
+                        progress: { $type: 'object' },
+                        'command.createIndexes': { $exists: true },
+                    },
+                },
+                {
+                    // explode the "indexes" array for each createIndexes command
+                    $unwind: '$command.indexes',
+                },
+                {
+                    // group on index name
+                    $group: {
+                        _id: '$command.indexes.name',
+                        progress: {
+                            $first: {
+                                $cond: {
+                                    if: { $gt: ['$progress.total', 0] },
+                                    then: { $divide: ['$progress.done', '$progress.total'] },
+                                    else: 0,
                                 },
                             },
                         },
                     },
-                ];
-                let currentOps = [];
-                const db = this._database('admin', 'META');
+                },
+            ];
+            let currentOps = [];
+            const db = this._database('admin', 'META');
+            try {
+                currentOps = (await db
+                    .aggregate(pipeline)
+                    .toArray());
+            }
+            catch {
+                // Try limiting the permissions needed:
+                currentOp.$currentOp.allUsers = false;
                 try {
                     currentOps = (await db
                         .aggregate(pipeline)
                         .toArray());
                 }
                 catch {
-                    // Try limiting the permissions needed:
-                    currentOp.$currentOp.allUsers = false;
-                    try {
-                        currentOps = (await db
-                            .aggregate(pipeline)
-                            .toArray());
-                    }
-                    catch {
-                        // ignore errors
-                    }
+                    // ignore errors
                 }
-                const indexToProgress = Object.create(null);
-                for (const { _id, progress } of currentOps) {
-                    indexToProgress[_id] = progress;
-                }
-                return indexToProgress;
             }
-            async fetchShardKey(ns, options = {}, executionOptions) {
-                const docs = await this.find('config.collections', {
-                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                    _id: ns,
-                    // unsplittable introduced in SPM-3364 to mark unsharded collections
-                    // that are still being tracked in the catalog
-                    unsplittable: { $ne: true },
-                }, { ...options, projection: { key: 1, _id: 0 } }, { abortSignal: executionOptions?.abortSignal });
-                return docs.length ? docs[0].key : null;
+            const indexToProgress = Object.create(null);
+            for (const { _id, progress } of currentOps) {
+                indexToProgress[_id] = progress;
             }
-            async _fetchShardKeyWithSilentFail(...args) {
-                try {
-                    return await this.fetchShardKey(...args);
-                }
-                catch (err) {
-                    // Rethrow if we aborted along the way.
-                    if (this.isCancelError(err)) {
-                        throw err;
-                    }
-                    // Return null on error.
-                    // This is oftentimes a lack of permissions to run a find on config.collections.
-                    return null;
-                }
+            return indexToProgress;
+        }
+        async fetchShardKey(ns, options = {}, executionOptions) {
+            const docs = await this.find('config.collections', {
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                _id: ns,
+                // unsplittable introduced in SPM-3364 to mark unsharded collections
+                // that are still being tracked in the catalog
+                unsplittable: { $ne: true },
+            }, { ...options, projection: { key: 1, _id: 0 } }, { abortSignal: executionOptions?.abortSignal });
+            return docs.length ? docs[0].key : null;
+        }
+        async _fetchShardKeyWithSilentFail(...args) {
+            try {
+                return await this.fetchShardKey(...args);
             }
-            async indexes(ns, options) {
-                if (options?.full === false) {
-                    const indexes = Object.entries(await this._collection(ns, 'CRUD').indexes({ ...options, full: false }));
-                    return indexes.map((compactIndexEntry) => {
-                        const [name, keys] = compactIndexEntry;
-                        return (0, index_detail_helper_1.createIndexDefinition)(ns, null, {
-                            name,
-                            key: Object.fromEntries(keys),
-                        });
-                    });
+            catch (err) {
+                // Rethrow if we aborted along the way.
+                if (this.isCancelError(err)) {
+                    throw err;
                 }
-                const [indexes, indexStats, indexSizes, indexProgress, shardKey] = await Promise.all([
-                    this._collection(ns, 'CRUD').indexes({ ...options, full: true }),
-                    this._indexStats(ns),
-                    this._indexSizes(ns),
-                    this._indexProgress(ns),
-                    this._fetchShardKeyWithSilentFail(ns),
-                ]);
-                const maxSize = Math.max(...Object.values(indexSizes));
-                return indexes
-                    .filter((index) => {
-                    return !!index.name;
-                })
-                    .map((index) => {
-                    const name = index.name;
-                    return (0, index_detail_helper_1.createIndexDefinition)(ns, shardKey ?? null, index, indexStats[name], indexSizes[name], maxSize, indexProgress[name]);
-                });
-            }
-            async instance() {
-                return {
-                    ...(await (0, instance_detail_helper_2.getInstance)(this._initializedClient('META'), this._connectionOptions.connectionString)),
-                    // Need to get the CSFLE flag from the CRUD client, not the META one
-                    csfleMode: this.getCSFLEMode(),
-                };
-            }
-            async insertOne(ns, doc, options) {
-                const coll = this._collection(ns, 'CRUD');
-                return await coll.insertOne(doc, options);
-            }
-            async insertMany(ns, docs, options) {
-                const coll = this._collection(ns, 'CRUD');
-                return await coll.insertMany(docs, options);
+                // Return null on error.
+                // This is oftentimes a lack of permissions to run a find on config.collections.
+                return null;
             }
-            async updateCollection(ns, 
-            // Collection name to update that will be passed to the collMod command will
-            // be derived from the provided namespace, this is why we are explicitly
-            // prohibiting to pass collMod flag here
-            flags = {}) {
-                const collectionName = this._collectionName(ns);
-                const db = this._database(ns, 'CRUD');
-                const result = await (0, run_command_1.runCommand)(db, {
-                    // Order of arguments is important here, collMod is a command name and it
-                    // should always be the first one in the object
-                    collMod: collectionName,
-                    ...flags,
+        }
+        async indexes(ns, options) {
+            if (options?.full === false) {
+                const indexes = Object.entries(await this._collection(ns, 'CRUD').indexes({ ...options, full: false }));
+                return indexes.map((compactIndexEntry) => {
+                    const [name, keys] = compactIndexEntry;
+                    return (0, index_detail_helper_1.createIndexDefinition)(ns, null, {
+                        name,
+                        key: Object.fromEntries(keys),
+                    });
                 });
-                // Reset the CSFLE-enabled client (if any) to clear any collection
-                // metadata caches that might still be active.
-                await this._resetCRUDClient();
-                return result;
-            }
-            bulkWrite(ns, operations, options) {
-                return this._collection(ns, 'CRUD').bulkWrite(operations, options);
             }
-            async currentOp() {
-                const db = this._database('admin', 'META');
-                const pipelineWithTruncateOps = [
-                    {
-                        $currentOp: {
-                            allUsers: true,
-                            idleConnections: false,
-                            truncateOps: false,
-                        },
+            const [indexes, indexStats, indexSizes, indexProgress, shardKey] = await Promise.all([
+                this._collection(ns, 'CRUD').indexes({ ...options, full: true }),
+                this._indexStats(ns),
+                this._indexSizes(ns),
+                this._indexProgress(ns),
+                this._fetchShardKeyWithSilentFail(ns),
+            ]);
+            const maxSize = Math.max(...Object.values(indexSizes));
+            return indexes
+                .filter((index) => {
+                return !!index.name;
+            })
+                .map((index) => {
+                const name = index.name;
+                return (0, index_detail_helper_1.createIndexDefinition)(ns, shardKey ?? null, index, indexStats[name], indexSizes[name], maxSize, indexProgress[name]);
+            });
+        }
+        async instance() {
+            return {
+                ...(await (0, instance_detail_helper_2.getInstance)(this._initializedClient('META'), this._connectionOptions.connectionString)),
+                // Need to get the CSFLE flag from the CRUD client, not the META one
+                csfleMode: this.getCSFLEMode(),
+            };
+        }
+        async insertOne(ns, doc, options) {
+            const coll = this._collection(ns, 'CRUD');
+            return await coll.insertOne(doc, options);
+        }
+        async insertMany(ns, docs, options) {
+            const coll = this._collection(ns, 'CRUD');
+            return await coll.insertMany(docs, options);
+        }
+        async updateCollection(ns, 
+        // Collection name to update that will be passed to the collMod command will
+        // be derived from the provided namespace, this is why we are explicitly
+        // prohibiting to pass collMod flag here
+        flags = {}) {
+            const collectionName = this._collectionName(ns);
+            const db = this._database(ns, 'CRUD');
+            const result = await (0, run_command_1.runCommand)(db, {
+                // Order of arguments is important here, collMod is a command name and it
+                // should always be the first one in the object
+                collMod: collectionName,
+                ...flags,
+            });
+            // Reset the CSFLE-enabled client (if any) to clear any collection
+            // metadata caches that might still be active.
+            await this._resetCRUDClient();
+            return result;
+        }
+        bulkWrite(ns, operations, options) {
+            return this._collection(ns, 'CRUD').bulkWrite(operations, options);
+        }
+        async currentOp() {
+            const db = this._database('admin', 'META');
+            const pipelineWithTruncateOps = [
+                {
+                    $currentOp: {
+                        allUsers: true,
+                        idleConnections: false,
+                        truncateOps: false,
                     },
-                ];
-                const currentOp = await db.aggregate(pipelineWithTruncateOps).toArray();
-                return { inprog: currentOp };
-            }
-            getLastSeenTopology() {
-                return this._lastSeenTopology;
-            }
-            async serverStatus() {
-                const admin = this._database('admin', 'META');
-                return await (0, run_command_1.runCommand)(admin, { serverStatus: 1 }, { enableUtf8Validation: false });
+                },
+            ];
+            const currentOp = await db.aggregate(pipelineWithTruncateOps).toArray();
+            return { inprog: currentOp };
+        }
+        getLastSeenTopology() {
+            return this._lastSeenTopology;
+        }
+        async serverStatus() {
+            const admin = this._database('admin', 'META');
+            return await (0, run_command_1.runCommand)(admin, { serverStatus: 1 }, { enableUtf8Validation: false });
+        }
+        async top() {
+            const adminDb = this._database('admin', 'META');
+            return await (0, run_command_1.runCommand)(adminDb, { top: 1 }, { enableUtf8Validation: false });
+        }
+        async createView(name, sourceNs, pipeline, options = {}) {
+            const createCollectionOptions = {
+                ...options,
+                viewOn: this._collectionName(sourceNs),
+                pipeline,
+            };
+            const db = this._database(sourceNs, 'CRUD');
+            return await db.createCollection(name, createCollectionOptions);
+        }
+        _buildSamplingPipeline({ query, size, fields }) {
+            const pipeline = [];
+            if (query && Object.keys(query).length > 0) {
+                pipeline.push({
+                    $match: query,
+                });
             }
-            async top() {
-                const adminDb = this._database('admin', 'META');
-                return await (0, run_command_1.runCommand)(adminDb, { top: 1 }, { enableUtf8Validation: false });
+            pipeline.push({
+                $sample: {
+                    size: size === 0 ? 0 : size || 1000,
+                },
+            });
+            // add $project stage if projection (fields) was specified
+            if (fields && Object.keys(fields).length > 0) {
+                pipeline.push({
+                    $project: fields,
+                });
             }
-            async createView(name, sourceNs, pipeline, options = {}) {
-                const createCollectionOptions = {
-                    ...options,
-                    viewOn: this._collectionName(sourceNs),
-                    pipeline,
+            return pipeline;
+        }
+        sampleCursor(ns, samplingOptions = {}, options = {}, executionOptions) {
+            const pipeline = this._buildSamplingPipeline(samplingOptions);
+            return this.aggregateCursor(ns, pipeline, {
+                allowDiskUse: true,
+                // When the read preference isn't set in the connection string explicitly,
+                // then we allow consumers to default to a read preference, for instance
+                // secondaryPreferred to avoid using the primary for analyzing documents.
+                ...this._getOptionsWithFallbackReadPreference(options, executionOptions),
+            });
+        }
+        sample(ns, samplingOptions = {}, options = {}, executionOptions) {
+            const pipeline = this._buildSamplingPipeline(samplingOptions);
+            return this.aggregate(ns, pipeline, {
+                allowDiskUse: true,
+                // When the read preference isn't set in the connection string explicitly,
+                // then we allow consumers to default to a read preference, for instance
+                // secondaryPreferred to avoid using the primary for analyzing documents.
+                ...this._getOptionsWithFallbackReadPreference(options, executionOptions),
+            }, executionOptions);
+        }
+        _startSession(clientType) {
+            const session = this._initializedClient(clientType).startSession();
+            session[kSessionClientType] = clientType;
+            return session;
+        }
+        _killSessions(sessions) {
+            const sessionsArray = Array.isArray(sessions) ? sessions : [sessions];
+            const clientTypes = new Set(sessionsArray.map((s) => s[kSessionClientType]));
+            if (clientTypes.size !== 1) {
+                throw new Error(`Cannot kill sessions without a specific client type: [${[
+                    ...clientTypes,
+                ].join(', ')}]`);
+            }
+            const [clientType] = clientTypes;
+            return (0, run_command_1.runCommand)(this._database('admin', clientType), {
+                killSessions: sessionsArray.map((s) => s.id),
+            });
+        }
+        isConnected() {
+            // This is better than just returning internal `_isConnecting` as this
+            // actually shows when the client is available on the NativeClient instance
+            // and connected
+            return !!this._metadataClient;
+        }
+        async _cancellableOperation(start, stop = () => Promise.resolve(), abortSignal) {
+            if (!abortSignal) {
+                return await start();
+            }
+            if (abortSignal.aborted) {
+                // AbortSignal.reason is supported from node v17.2.0.
+                throw abortSignal.reason ?? (0, compass_utils_1.createCancelError)();
+            }
+            const session = this._startSession('CRUD');
+            let result;
+            const abort = async () => {
+                const logAbortError = (error) => {
+                    this._logger.warn((0, logger_1.mongoLogId)(1_001_000_140), 'Attempting to kill the operation failed', { error: error.message });
                 };
-                const db = this._database(sourceNs, 'CRUD');
-                return await db.createCollection(name, createCollectionOptions);
+                await stop(session).catch(logAbortError);
+                await this._killSessions(session).catch(logAbortError);
+            };
+            try {
+                result = await (0, compass_utils_1.raceWithAbort)(start(session), abortSignal);
             }
-            _buildSamplingPipeline({ query, size, fields }) {
-                const pipeline = [];
-                if (query && Object.keys(query).length > 0) {
-                    pipeline.push({
-                        $match: query,
-                    });
+            catch (err) {
+                if ((0, compass_utils_1.isCancelError)(err)) {
+                    await abort();
                 }
-                pipeline.push({
-                    $sample: {
-                        size: size === 0 ? 0 : size || 1000,
-                    },
+                throw err;
+            }
+            return result;
+        }
+        isCancelError(error) {
+            return (0, compass_utils_1.isCancelError)(error);
+        }
+        _setupListeners(client) {
+            if (client) {
+                client.on('connectionCreated', (evt) => {
+                    const { address, connectionId } = evt;
+                    this._logger.info((0, logger_1.mongoLogId)(1_001_000_027), 'Driver connection created', {
+                        address,
+                        serverConnectionId: connectionId,
+                    });
                 });
-                // add $project stage if projection (fields) was specified
-                if (fields && Object.keys(fields).length > 0) {
-                    pipeline.push({
-                        $project: fields,
+                client.on('serverDescriptionChanged', (evt) => {
+                    this._logger.info((0, logger_1.mongoLogId)(1_001_000_018), 'Server description changed', {
+                        address: evt.address,
+                        error: evt.newDescription.error?.message ?? null,
+                        previousType: evt.previousDescription.type,
+                        newType: evt.newDescription.type,
                     });
-                }
-                return pipeline;
-            }
-            sampleCursor(ns, samplingOptions = {}, options = {}, executionOptions) {
-                const pipeline = this._buildSamplingPipeline(samplingOptions);
-                return this.aggregateCursor(ns, pipeline, {
-                    allowDiskUse: true,
-                    // When the read preference isn't set in the connection string explicitly,
-                    // then we allow consumers to default to a read preference, for instance
-                    // secondaryPreferred to avoid using the primary for analyzing documents.
-                    ...this._getOptionsWithFallbackReadPreference(options, executionOptions),
                 });
-            }
-            sample(ns, samplingOptions = {}, options = {}, executionOptions) {
-                const pipeline = this._buildSamplingPipeline(samplingOptions);
-                return this.aggregate(ns, pipeline, {
-                    allowDiskUse: true,
-                    // When the read preference isn't set in the connection string explicitly,
-                    // then we allow consumers to default to a read preference, for instance
-                    // secondaryPreferred to avoid using the primary for analyzing documents.
-                    ...this._getOptionsWithFallbackReadPreference(options, executionOptions),
-                }, executionOptions);
-            }
-            _startSession(clientType) {
-                const session = this._initializedClient(clientType).startSession();
-                session[kSessionClientType] = clientType;
-                return session;
-            }
-            _killSessions(sessions) {
-                const sessionsArray = Array.isArray(sessions) ? sessions : [sessions];
-                const clientTypes = new Set(sessionsArray.map((s) => s[kSessionClientType]));
-                if (clientTypes.size !== 1) {
-                    throw new Error(`Cannot kill sessions without a specific client type: [${[
-                        ...clientTypes,
-                    ].join(', ')}]`);
-                }
-                const [clientType] = clientTypes;
-                return (0, run_command_1.runCommand)(this._database('admin', clientType), {
-                    killSessions: sessionsArray.map((s) => s.id),
+                client.on('serverOpening', (evt) => {
+                    this._logger.info((0, logger_1.mongoLogId)(1_001_000_019), 'Server opening', {
+                        address: evt.address,
+                    });
                 });
-            }
-            isConnected() {
-                // This is better than just returning internal `_isConnecting` as this
-                // actually shows when the client is available on the NativeClient instance
-                // and connected
-                return !!this._metadataClient;
-            }
-            async _cancellableOperation(start, stop = () => Promise.resolve(), abortSignal) {
-                if (!abortSignal) {
-                    return await start();
-                }
-                if (abortSignal.aborted) {
-                    // AbortSignal.reason is supported from node v17.2.0.
-                    throw abortSignal.reason ?? (0, compass_utils_1.createCancelError)();
-                }
-                const session = this._startSession('CRUD');
-                let result;
-                const abort = async () => {
-                    const logAbortError = (error) => {
-                        this._logger.warn((0, logger_1.mongoLogId)(1_001_000_140), 'Attempting to kill the operation failed', { error: error.message });
+                client.on('close', () => {
+                    this._logger.info((0, logger_1.mongoLogId)(1_001_000_315), 'Client is closed');
+                    this._emitter.emit('close');
+                });
+                client.on('serverClosed', (evt) => {
+                    this._logger.info((0, logger_1.mongoLogId)(1_001_000_020), 'Server closed', {
+                        address: evt.address,
+                    });
+                });
+                client.on('topologyDescriptionChanged', (evt) => {
+                    this._isWritable = this._checkIsWritable(evt);
+                    const attr = {
+                        isWritable: this.isWritable(),
+                        isMongos: this.isMongos(),
+                        previousType: evt.previousDescription.type,
+                        newType: evt.newDescription.type,
                     };
-                    await stop(session).catch(logAbortError);
-                    await this._killSessions(session).catch(logAbortError);
+                    this._logger.info((0, logger_1.mongoLogId)(1_001_000_021), 'Topology description changed', attr);
+                    this._lastSeenTopology = evt.newDescription;
+                    this._emitter.emit('topologyDescriptionChanged', evt);
+                });
+                // Heartbeat events are fairly noisy. We put some effort into
+                // making sure that we only log events that actually contain
+                // meaningful information.
+                const heartbeatStatusMap = new Map();
+                const isSignificantDurationChange = (before, after) => {
+                    // Changes in pings below 200ms are not particularly concerning here.
+                    before = Math.max(before, 200);
+                    after = Math.max(after, 200);
+                    // Check if changes is at least 2× (in either direction).
+                    return Math.abs(Math.log2(before / after)) >= 1;
                 };
-                try {
-                    result = await (0, compass_utils_1.raceWithAbort)(start(session), abortSignal);
-                }
-                catch (err) {
-                    if ((0, compass_utils_1.isCancelError)(err)) {
-                        await abort();
-                    }
-                    throw err;
-                }
-                return result;
-            }
-            isCancelError(error) {
-                return (0, compass_utils_1.isCancelError)(error);
-            }
-            _setupListeners(client) {
-                if (client) {
-                    client.on('connectionCreated', (evt) => {
-                        const { address, connectionId } = evt;
-                        this._logger.info((0, logger_1.mongoLogId)(1_001_000_027), 'Driver connection created', {
-                            address,
-                            serverConnectionId: connectionId,
-                        });
-                    });
-                    client.on('serverDescriptionChanged', (evt) => {
-                        this._logger.info((0, logger_1.mongoLogId)(1_001_000_018), 'Server description changed', {
-                            address: evt.address,
-                            error: evt.newDescription.error?.message ?? null,
-                            previousType: evt.previousDescription.type,
-                            newType: evt.newDescription.type,
+                client.on('serverHeartbeatSucceeded', (evt) => {
+                    const previousStatus = heartbeatStatusMap.get(evt.connectionId);
+                    if (!previousStatus ||
+                        previousStatus.failure ||
+                        isSignificantDurationChange(previousStatus.duration, evt.duration)) {
+                        heartbeatStatusMap.set(evt.connectionId, {
+                            failure: null,
+                            duration: evt.duration,
                         });
-                    });
-                    client.on('serverOpening', (evt) => {
-                        this._logger.info((0, logger_1.mongoLogId)(1_001_000_019), 'Server opening', {
-                            address: evt.address,
+                        this._logger.debug((0, logger_1.mongoLogId)(1_001_000_022), 'Server heartbeat succeeded', {
+                            connectionId: evt.connectionId,
+                            duration: evt.duration,
                         });
-                    });
-                    client.on('close', () => {
-                        this._logger.info((0, logger_1.mongoLogId)(1_001_000_315), 'Client is closed');
-                        this._emitter.emit('close');
-                    });
-                    client.on('serverClosed', (evt) => {
-                        this._logger.info((0, logger_1.mongoLogId)(1_001_000_020), 'Server closed', {
-                            address: evt.address,
+                    }
+                });
+                client.on('serverHeartbeatFailed', (evt) => {
+                    const previousStatus = heartbeatStatusMap.get(evt.connectionId);
+                    if (!previousStatus ||
+                        !previousStatus.failure ||
+                        isSignificantDurationChange(previousStatus.duration, evt.duration)) {
+                        heartbeatStatusMap.set(evt.connectionId, {
+                            failure: evt.failure.message,
+                            duration: evt.duration,
                         });
-                    });
-                    client.on('topologyDescriptionChanged', (evt) => {
-                        this._isWritable = this._checkIsWritable(evt);
-                        const attr = {
-                            isWritable: this.isWritable(),
-                            isMongos: this.isMongos(),
-                            previousType: evt.previousDescription.type,
-                            newType: evt.newDescription.type,
-                        };
-                        this._logger.info((0, logger_1.mongoLogId)(1_001_000_021), 'Topology description changed', attr);
-                        this._lastSeenTopology = evt.newDescription;
-                        this._emitter.emit('topologyDescriptionChanged', evt);
-                    });
-                    // Heartbeat events are fairly noisy. We put some effort into
-                    // making sure that we only log events that actually contain
-                    // meaningful information.
-                    const heartbeatStatusMap = new Map();
-                    const isSignificantDurationChange = (before, after) => {
-                        // Changes in pings below 200ms are not particularly concerning here.
-                        before = Math.max(before, 200);
-                        after = Math.max(after, 200);
-                        // Check if changes is at least 2× (in either direction).
-                        return Math.abs(Math.log2(before / after)) >= 1;
-                    };
-                    client.on('serverHeartbeatSucceeded', (evt) => {
-                        const previousStatus = heartbeatStatusMap.get(evt.connectionId);
-                        if (!previousStatus ||
-                            previousStatus.failure ||
-                            isSignificantDurationChange(previousStatus.duration, evt.duration)) {
-                            heartbeatStatusMap.set(evt.connectionId, {
-                                failure: null,
-                                duration: evt.duration,
-                            });
-                            this._logger.debug((0, logger_1.mongoLogId)(1_001_000_022), 'Server heartbeat succeeded', {
-                                connectionId: evt.connectionId,
-                                duration: evt.duration,
-                            });
-                        }
-                    });
-                    client.on('serverHeartbeatFailed', (evt) => {
-                        const previousStatus = heartbeatStatusMap.get(evt.connectionId);
-                        if (!previousStatus ||
-                            !previousStatus.failure ||
-                            isSignificantDurationChange(previousStatus.duration, evt.duration)) {
-                            heartbeatStatusMap.set(evt.connectionId, {
-                                failure: evt.failure.message,
-                                duration: evt.duration,
-                            });
-                            this._logger.warn((0, logger_1.mongoLogId)(1_001_000_023), 'Server heartbeat failed', {
-                                connectionId: evt.connectionId,
-                                duration: evt.duration,
-                                failure: evt.failure.message,
-                            });
-                        }
-                        this._emitter.emit('serverHeartbeatFailed', evt);
-                    });
-                    client.on('commandStarted', (evt) => {
-                        const { address, connectionId, requestId, commandName, databaseName } = evt;
-                        this._logger.debug((0, logger_1.mongoLogId)(1_001_000_028), 'Driver command started', {
-                            address,
-                            databaseName,
-                            serverConnectionId: connectionId,
-                            requestId,
-                            commandName,
+                        this._logger.warn((0, logger_1.mongoLogId)(1_001_000_023), 'Server heartbeat failed', {
+                            connectionId: evt.connectionId,
+                            duration: evt.duration,
+                            failure: evt.failure.message,
                         });
+                    }
+                    this._emitter.emit('serverHeartbeatFailed', evt);
+                });
+                client.on('commandStarted', (evt) => {
+                    const { address, connectionId, requestId, commandName, databaseName } = evt;
+                    this._logger.debug((0, logger_1.mongoLogId)(1_001_000_028), 'Driver command started', {
+                        address,
+                        databaseName,
+                        serverConnectionId: connectionId,
+                        requestId,
+                        commandName,
                     });
-                    client.on('commandSucceeded', (evt) => {
-                        const { address, connectionId, duration, requestId, commandName } = evt;
-                        this._logger.debug((0, logger_1.mongoLogId)(1_001_000_029), 'Driver command succeeded', {
-                            address,
-                            requestId,
-                            serverConnectionId: connectionId,
-                            duration,
-                            commandName,
-                        });
+                });
+                client.on('commandSucceeded', (evt) => {
+                    const { address, connectionId, duration, requestId, commandName } = evt;
+                    this._logger.debug((0, logger_1.mongoLogId)(1_001_000_029), 'Driver command succeeded', {
+                        address,
+                        requestId,
+                        serverConnectionId: connectionId,
+                        duration,
+                        commandName,
                     });
-                    client.on('commandFailed', (evt) => {
-                        const { address, connectionId, duration, requestId, commandName, failure, } = evt;
-                        this._logger.debug((0, logger_1.mongoLogId)(1_001_000_030), 'Driver command failed', {
-                            address,
-                            serverConnectionId: connectionId,
-                            duration,
-                            requestId,
-                            commandName,
-                            failure: failure.message,
-                        });
+                });
+                client.on('commandFailed', (evt) => {
+                    const { address, connectionId, duration, requestId, commandName, failure, } = evt;
+                    this._logger.debug((0, logger_1.mongoLogId)(1_001_000_030), 'Driver command failed', {
+                        address,
+                        serverConnectionId: connectionId,
+                        duration,
+                        requestId,
+                        commandName,
+                        failure: failure.message,
                     });
-                }
-            }
-            _initializedClient(type) {
-                if (type !== 'CRUD' && type !== 'META') {
-                    throw new Error(`Invalid client type: ${type}`);
-                }
-                const client = type === 'CRUD' && this._useCRUDClient
-                    ? this._crudClient
-                    : this._metadataClient;
-                if (!client) {
-                    throw new Error(`Client not yet initialized [${type}]`);
-                }
-                return client;
-            }
-            _getCSFLECollectionTracker() {
-                if (!this._csfleCollectionTracker) {
-                    throw new Error(`Client not yet initialized [CSFLECollectionTracker]`);
-                }
-                return this._csfleCollectionTracker;
+                });
             }
-            isUpdateAllowed(ns, originalDocument) {
-                return this._getCSFLECollectionTracker().isUpdateAllowed(ns, originalDocument);
+        }
+        _initializedClient(type) {
+            if (type !== 'CRUD' && type !== 'META') {
+                throw new Error(`Invalid client type: ${type}`);
             }
-            knownSchemaForCollection(ns) {
-                return this._getCSFLECollectionTracker().knownSchemaForCollection(ns);
+            const client = type === 'CRUD' && this._useCRUDClient
+                ? this._crudClient
+                : this._metadataClient;
+            if (!client) {
+                throw new Error(`Client not yet initialized [${type}]`);
             }
-            async databaseStats(name) {
-                const db = this._database(name, 'META');
-                const stats = await (0, run_command_1.runCommand)(db, { dbStats: 1 }, {
-                    enableUtf8Validation: false,
-                    ...maybeOverrideReadPreference(this.isMongos(), this._crudClient?.readPreference),
-                });
-                const normalized = (0, instance_detail_helper_2.adaptDatabaseInfo)(stats);
-                return { name, ...normalized };
+            return client;
+        }
+        _getCSFLECollectionTracker() {
+            if (!this._csfleCollectionTracker) {
+                throw new Error(`Client not yet initialized [CSFLECollectionTracker]`);
             }
-            async previewUpdate(ns, filter, update, executionOptions = {}) {
-                const { abortSignal = new AbortController().signal, sample = 10, timeout = 1000, } = executionOptions;
-                const startTimeMS = Date.now();
-                const remainingTimeoutMS = () => Math.max(1, timeout - (Date.now() - startTimeMS));
-                return await this._cancellableOperation(async (session) => {
-                    if (!session) {
-                        throw new Error('Could not open session.');
-                    }
-                    try {
-                        return await session.withTransaction(async () => {
-                            const coll = this._collection(ns, 'CRUD');
-                            const docsToPreview = await coll
-                                .find(filter, {
-                                session,
-                                maxTimeMS: remainingTimeoutMS(),
-                                // by using promoteValues: false we can spot BSON type changes
-                                // when diffing. ie. new Double(1) -> new Int32(1)
-                                promoteValues: false,
-                            })
-                                .sort({ _id: 1 })
-                                .limit(sample)
-                                .toArray();
-                            const idsToPreview = docsToPreview.map((doc) => doc._id);
-                            await coll.updateMany({ _id: { $in: idsToPreview } }, update, {
-                                session,
-                                maxTimeMS: remainingTimeoutMS(),
-                            });
-                            const changedDocs = await coll
-                                .find({ _id: { $in: idsToPreview } }, {
-                                session,
-                                maxTimeMS: remainingTimeoutMS(),
-                                promoteValues: false,
-                            })
-                                .sort({ _id: 1 })
-                                .toArray();
-                            await session.abortTransaction();
-                            await session.endSession();
-                            const changes = docsToPreview.map((before, idx) => ({
-                                before,
-                                after: changedDocs[idx],
-                            }));
-                            return { changes };
-                        }, {
+            return this._csfleCollectionTracker;
+        }
+        isUpdateAllowed(ns, originalDocument) {
+            return this._getCSFLECollectionTracker().isUpdateAllowed(ns, originalDocument);
+        }
+        knownSchemaForCollection(ns) {
+            return this._getCSFLECollectionTracker().knownSchemaForCollection(ns);
+        }
+        async databaseStats(name) {
+            const db = this._database(name, 'META');
+            const stats = await (0, run_command_1.runCommand)(db, { dbStats: 1 }, {
+                enableUtf8Validation: false,
+                ...maybeOverrideReadPreference(this.isMongos(), this._crudClient?.readPreference),
+            });
+            const normalized = (0, instance_detail_helper_2.adaptDatabaseInfo)(stats);
+            return { name, ...normalized };
+        }
+        async previewUpdate(ns, filter, update, executionOptions = {}) {
+            const { abortSignal = new AbortController().signal, sample = 10, timeout = 1000, } = executionOptions;
+            const startTimeMS = Date.now();
+            const remainingTimeoutMS = () => Math.max(1, timeout - (Date.now() - startTimeMS));
+            return await this._cancellableOperation(async (session) => {
+                if (!session) {
+                    throw new Error('Could not open session.');
+                }
+                try {
+                    return await session.withTransaction(async () => {
+                        const coll = this._collection(ns, 'CRUD');
+                        const docsToPreview = await coll
+                            .find(filter, {
+                            session,
+                            maxTimeMS: remainingTimeoutMS(),
+                            // by using promoteValues: false we can spot BSON type changes
+                            // when diffing. ie. new Double(1) -> new Int32(1)
+                            promoteValues: false,
+                        })
+                            .sort({ _id: 1 })
+                            .limit(sample)
+                            .toArray();
+                        const idsToPreview = docsToPreview.map((doc) => doc._id);
+                        await coll.updateMany({ _id: { $in: idsToPreview } }, update, {
+                            session,
                             maxTimeMS: remainingTimeoutMS(),
                         });
+                        const changedDocs = await coll
+                            .find({ _id: { $in: idsToPreview } }, {
+                            session,
+                            maxTimeMS: remainingTimeoutMS(),
+                            promoteValues: false,
+                        })
+                            .sort({ _id: 1 })
+                            .toArray();
+                        await session.abortTransaction();
+                        await session.endSession();
+                        const changes = docsToPreview.map((before, idx) => ({
+                            before,
+                            after: changedDocs[idx],
+                        }));
+                        return { changes };
+                    }, {
+                        maxTimeMS: remainingTimeoutMS(),
+                    });
+                }
+                catch (err) {
+                    if (isTransactionAbortError(err)) {
+                        // The transaction was aborted while it was still calculating the
+                        // preview. Just return something here rather than erroring. No
+                        // reason to abort the transaction or end the session again because
+                        // we only got here because that already happened.
+                        return { changes: [] };
                     }
-                    catch (err) {
-                        if (isTransactionAbortError(err)) {
-                            // The transaction was aborted while it was still calculating the
-                            // preview. Just return something here rather than erroring. No
-                            // reason to abort the transaction or end the session again because
-                            // we only got here because that already happened.
-                            return { changes: [] };
-                        }
-                        // The only way this if statement would be true is if aborting the
-                        // transaction and ending the session itself failed above. Unlikely.
-                        if (session.inTransaction()) {
-                            await session.abortTransaction();
-                            await session.endSession();
-                        }
-                        throw err;
+                    // The only way this if statement would be true is if aborting the
+                    // transaction and ending the session itself failed above. Unlikely.
+                    if (session.inTransaction()) {
+                        await session.abortTransaction();
+                        await session.endSession();
                     }
-                }, async () => {
-                    // Rely on the session being killed when we cancel the operation. It can
-                    // take a few seconds before the driver reacts, but the Promise.race()
-                    // against the abort signal should cause the UI to immediately be
-                    // notified that the operation was cancelled. We don't abort the
-                    // transaction or end the session as well because the code we run inside
-                    // session.withTransaction() above would experience race conditions.
-                }, abortSignal);
-            }
-            /**
-             * @param databaseName - The name of the database.
-             * @param collectionName - The name of the collection.
-             * @param data - The result of the collStats command.
-             */
-            _buildCollectionStats(databaseName, collectionName, data) {
-                return {
-                    ns: databaseName + '.' + collectionName,
-                    name: collectionName,
-                    database: databaseName,
-                    is_capped: data.capped,
-                    document_count: data.count ?? 0,
-                    document_size: data.size,
-                    avg_document_size: data.avgObjSize ?? 0,
-                    storage_size: data.storageSize ?? 0,
-                    free_storage_size: data.freeStorageSize ?? 0,
-                    index_count: data.nindexes ?? 0,
-                    index_size: data.totalIndexSize ?? 0,
-                    bucket_count: data.bucket_count,
-                    avg_bucket_size: data.avg_bucket_size,
-                };
-            }
-            /**
-             * Get the collection to operate on.
-             *
-             * @param ns - The namespace.
-             */
-            _collection(ns, type) {
-                return this._initializedClient(type)
-                    .db(this._databaseName(ns))
-                    .collection(this._collectionName(ns));
-            }
-            /**
-             * Get the database to operate on.
-             *
-             * @param ns - The namespace.
-             */
-            _database(ns, type) {
-                return this._initializedClient(type).db(this._databaseName(ns));
-            }
-            /**
-             * Get the collection name from a namespace.
-             *
-             * @param ns - The namespace in database.collection format.
-             */
-            _collectionName(ns) {
-                return (0, mongodb_ns_1.default)(ns).collection;
-            }
-            /**
-             * Get the database name from a namespace.
-             *
-             * @param ns - The namespace in database.collection format.
-             */
-            _databaseName(ns) {
-                return (0, mongodb_ns_1.default)(ns).database;
-            }
-            /**
-             * Determine if the hello response indicates a writable server.
-             *
-             * @param evt - The topology description changed event.
-             *
-             * @returns If the server is writable.
-             */
-            _checkIsWritable(evt) {
-                return [...evt.newDescription.servers.values()].some((server) => server.isWritable);
-            }
-            _cleanup() {
-                this._emitter.removeAllListeners();
-                this._metadataClient?.removeAllListeners?.();
-                this._crudClient?.removeAllListeners?.();
-                this._metadataClient = undefined;
-                this._crudClient = undefined;
-                this._tunnel = undefined;
-                this._state = undefined;
-                this._mongoClientConnectionOptions = undefined;
-                this._isWritable = false;
-                this._isConnecting = false;
-            }
-            async _resetCRUDClient() {
-                if (this.getCSFLEMode() === 'unavailable') {
-                    // No separate client in use, don't do anything
-                    return;
-                }
-                const crudClient = this._crudClient;
-                if (!crudClient) {
-                    // In disconnected state, don't do anything
-                    return;
-                }
-                const newClient = await crudClient[connect_mongo_client_1.createClonedClient]();
-                if (this._crudClient === crudClient) {
-                    this._crudClient = newClient;
-                    await crudClient.close();
-                }
-                else {
-                    // If _crudClient has changed between start and end of
-                    // connection establishment, don't do anything, just
-                    // close and discard the new client.
-                    await newClient.close();
+                    throw err;
                 }
+            }, async () => {
+                // Rely on the session being killed when we cancel the operation. It can
+                // take a few seconds before the driver reacts, but the Promise.race()
+                // against the abort signal should cause the UI to immediately be
+                // notified that the operation was cancelled. We don't abort the
+                // transaction or end the session as well because the code we run inside
+                // session.withTransaction() above would experience race conditions.
+            }, abortSignal);
+        }
+        /**
+         * @param databaseName - The name of the database.
+         * @param collectionName - The name of the collection.
+         * @param data - The result of the collStats command.
+         */
+        _buildCollectionStats(databaseName, collectionName, data) {
+            return {
+                ns: databaseName + '.' + collectionName,
+                name: collectionName,
+                database: databaseName,
+                is_capped: data.capped,
+                document_count: data.count ?? 0,
+                document_size: data.size,
+                avg_document_size: data.avgObjSize ?? 0,
+                storage_size: data.storageSize ?? 0,
+                free_storage_size: data.freeStorageSize ?? 0,
+                index_count: data.nindexes ?? 0,
+                index_size: data.totalIndexSize ?? 0,
+                bucket_count: data.bucket_count,
+                avg_bucket_size: data.avg_bucket_size,
+            };
+        }
+        /**
+         * Get the collection to operate on.
+         *
+         * @param ns - The namespace.
+         */
+        _collection(ns, type) {
+            return this._initializedClient(type)
+                .db(this._databaseName(ns))
+                .collection(this._collectionName(ns));
+        }
+        /**
+         * Get the database to operate on.
+         *
+         * @param ns - The namespace.
+         */
+        _database(ns, type) {
+            return this._initializedClient(type).db(this._databaseName(ns));
+        }
+        /**
+         * Get the collection name from a namespace.
+         *
+         * @param ns - The namespace in database.collection format.
+         */
+        _collectionName(ns) {
+            return (0, mongodb_ns_1.default)(ns).collection;
+        }
+        /**
+         * Get the database name from a namespace.
+         *
+         * @param ns - The namespace in database.collection format.
+         */
+        _databaseName(ns) {
+            return (0, mongodb_ns_1.default)(ns).database;
+        }
+        /**
+         * Determine if the hello response indicates a writable server.
+         *
+         * @param evt - The topology description changed event.
+         *
+         * @returns If the server is writable.
+         */
+        _checkIsWritable(evt) {
+            return [...evt.newDescription.servers.values()].some((server) => server.isWritable);
+        }
+        _cleanup() {
+            this._emitter.removeAllListeners();
+            this._metadataClient?.removeAllListeners?.();
+            this._crudClient?.removeAllListeners?.();
+            this._metadataClient = undefined;
+            this._crudClient = undefined;
+            this._tunnel = undefined;
+            this._state = undefined;
+            this._mongoClientConnectionOptions = undefined;
+            this._isWritable = false;
+            this._isConnecting = false;
+        }
+        async _resetCRUDClient() {
+            if (this.getCSFLEMode() === 'unavailable') {
+                // No separate client in use, don't do anything
+                return;
+            }
+            const crudClient = this._crudClient;
+            if (!crudClient) {
+                // In disconnected state, don't do anything
+                return;
+            }
+            const newClient = await crudClient[connect_mongo_client_1.createClonedClient]();
+            if (this._crudClient === crudClient) {
+                this._crudClient = newClient;
+                await crudClient.close();
+            }
+            else {
+                // If _crudClient has changed between start and end of
+                // connection establishment, don't do anything, just
+                // close and discard the new client.
+                await newClient.close();
             }
-            configuredKMSProviders() {
-                return (0, instance_detail_helper_2.configuredKMSProviders)(this._connectionOptions.fleOptions?.autoEncryption);
-            }
-            _csfleLogInformation(fleOptions) {
-                const kmsProviders = (0, instance_detail_helper_2.configuredKMSProviders)(fleOptions?.autoEncryption);
-                if (kmsProviders.length === 0)
-                    return null;
-                return {
-                    storeCredentials: fleOptions?.storeCredentials,
-                    encryptedFieldsMapNamespaces: Object.keys({
-                        ...fleOptions?.autoEncryption?.encryptedFieldsMap,
-                        ...fleOptions?.autoEncryption?.schemaMap,
-                    }),
-                    keyVaultNamespace: fleOptions?.autoEncryption?.keyVaultNamespace,
-                    kmsProviders,
-                };
-            }
-            async createDataKey(provider, options) {
-                const clientEncryption = this._getClientEncryption();
-                return await clientEncryption.createDataKey(provider, options ?? {});
-            }
-            _getClientEncryption() {
-                const crudClient = this._initializedClient('CRUD');
-                const autoEncryptionOptions = crudClient.options.autoEncryption;
-                const { proxyHost, proxyPort, proxyUsername, proxyPassword } = crudClient.options;
-                return new mongodb_1.ClientEncryption(crudClient, {
-                    keyVaultNamespace: autoEncryptionOptions.keyVaultNamespace,
-                    kmsProviders: autoEncryptionOptions.kmsProviders,
-                    tlsOptions: autoEncryptionOptions.tlsOptions,
-                    proxyOptions: proxyHost
-                        ? {
-                            proxyHost,
-                            proxyPort,
-                            proxyUsername,
-                            proxyPassword,
-                        }
-                        : undefined,
-                });
-            }
-            async getUpdatedSecrets() {
-                if (!this._state)
-                    return {};
-                return {
-                    oidc: {
-                        serializedState: await this._state.oidcPlugin.serialize(),
-                    },
-                };
-            }
-            async listStreamProcessors(filter) {
-                const adminDb = this._database('admin', 'CRUD');
-                const { streamProcessors } = await (0, run_command_1.runCommand)(adminDb, {
-                    listStreamProcessors: 1,
-                    filter,
-                });
-                return streamProcessors;
-            }
-            async startStreamProcessor(name) {
-                const adminDb = this._database('admin', 'CRUD');
-                await (0, run_command_1.runCommand)(adminDb, { startStreamProcessor: name });
-            }
-            async stopStreamProcessor(name) {
-                const adminDb = this._database('admin', 'CRUD');
-                await (0, run_command_1.runCommand)(adminDb, { stopStreamProcessor: name });
-            }
-            async dropStreamProcessor(name) {
-                const adminDb = this._database('admin', 'CRUD');
-                await (0, run_command_1.runCommand)(adminDb, { dropStreamProcessor: name });
-            }
-        },
-        (() => {
-            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
-            _collectionStats_decorators = [op((0, logger_1.mongoLogId)(1_001_000_178), ([dbName, collName], result) => {
-                    return { ns: `${dbName}.${collName}`, ...(result && { result }) };
-                })];
-            _collectionInfo_decorators = [op((0, logger_1.mongoLogId)(1_001_000_179))];
-            _killOp_decorators = [op((0, logger_1.mongoLogId)(1_001_000_031))];
-            __connectionStatus_decorators = [op((0, logger_1.mongoLogId)(1_001_000_100))];
-            _listCollections_decorators = [op((0, logger_1.mongoLogId)(1_001_000_032), ([databaseName, , options], colls) => {
-                    return {
-                        db: databaseName,
-                        nameOnly: options?.nameOnly ?? false,
-                        ...(colls && { collectionsCount: colls.length }),
-                    };
-                })];
-            _listDatabases_decorators = [op((0, logger_1.mongoLogId)(1_001_000_033), ([options], dbs) => {
-                    return {
-                        nameOnly: options?.nameOnly ?? false,
-                        ...(dbs && { databasesCount: dbs.length }),
-                    };
-                })];
-            _estimatedCount_decorators = [op((0, logger_1.mongoLogId)(1_001_000_034), ([ns, options]) => {
-                    return { ns, maxTimeMS: options?.maxTimeMS };
-                })];
-            _count_decorators = [op((0, logger_1.mongoLogId)(1_001_000_035))];
-            _createCollection_decorators = [op((0, logger_1.mongoLogId)(1_001_000_036), ([ns, options], result) => {
-                    return { ns, options, ...(result && { result }) };
-                })];
-            _createIndex_decorators = [op((0, logger_1.mongoLogId)(1_001_000_037), ([ns, spec, options], result) => {
-                    return { ns, spec, options, ...(result && { result }) };
-                })];
-            _deleteOne_decorators = [op((0, logger_1.mongoLogId)(1_001_000_038), ([ns], result) => {
-                    return { ns, ...(result && { result }) };
-                })];
-            _deleteMany_decorators = [op((0, logger_1.mongoLogId)(1_001_000_039), ([ns], result) => {
-                    return { ns, ...(result && { result }) };
-                })];
-            _dropCollection_decorators = [op((0, logger_1.mongoLogId)(1_001_000_059), ([ns], result) => {
-                    return { ns, ...(result && { result }) };
-                })];
-            _renameCollection_decorators = [op((0, logger_1.mongoLogId)(1_001_000_276))];
-            _dropDatabase_decorators = [op((0, logger_1.mongoLogId)(1_001_000_040), ([db], result) => {
-                    return { db, ...(result && { result }) };
-                })];
-            _dropIndex_decorators = [op((0, logger_1.mongoLogId)(1_001_000_182), ([ns, name], result) => {
-                    return { ns, name, ...(result && { result }) };
-                })];
-            _isListSearchIndexesSupported_decorators = [op((0, logger_1.mongoLogId)(1_001_000_237))];
-            _getSearchIndexes_decorators = [op((0, logger_1.mongoLogId)(1_001_000_238))];
-            _createSearchIndex_decorators = [op((0, logger_1.mongoLogId)(1_001_000_239))];
-            _updateSearchIndex_decorators = [op((0, logger_1.mongoLogId)(1_001_000_240))];
-            _dropSearchIndex_decorators = [op((0, logger_1.mongoLogId)(1_001_000_241))];
-            _aggregateCursor_decorators = [op((0, logger_1.mongoLogId)(1_001_000_041), ([ns, pipeline, options]) => {
-                    return {
-                        ns,
-                        stages: pipeline.map((stage) => Object.keys(stage)[0]),
-                        maxTimeMS: options?.maxTimeMS,
-                    };
-                })];
-            _aggregate_decorators = [op((0, logger_1.mongoLogId)(1_001_000_181), ([ns, pipeline, options]) => {
-                    return {
-                        ns,
-                        stages: pipeline.map((stage) => Object.keys(stage)[0]),
-                        maxTimeMS: options?.maxTimeMS,
-                    };
-                })];
-            _find_decorators = [op((0, logger_1.mongoLogId)(1_001_000_060), ([ns, , options]) => {
-                    return { ns, maxTimeMS: options?.maxTimeMS };
-                })];
-            _findCursor_decorators = [op((0, logger_1.mongoLogId)(1_001_000_043))];
-            _findOneAndReplace_decorators = [op((0, logger_1.mongoLogId)(1_001_000_044))];
-            _findOneAndUpdate_decorators = [op((0, logger_1.mongoLogId)(1_001_000_045))];
-            _updateOne_decorators = [op((0, logger_1.mongoLogId)(1_001_000_183))];
-            _replaceOne_decorators = [op((0, logger_1.mongoLogId)(1_001_000_191))];
-            _explainFind_decorators = [op((0, logger_1.mongoLogId)(1_001_000_046), ([ns, , , executionOptions]) => {
-                    return {
-                        ns,
-                        verbosity: executionOptions?.explainVerbosity || mongodb_1.ExplainVerbosity.executionStats,
-                    };
-                })];
-            _explainAggregate_decorators = [op((0, logger_1.mongoLogId)(1_001_000_177), ([ns, , , executionOptions]) => {
-                    return {
-                        ns,
-                        verbosity: executionOptions?.explainVerbosity || mongodb_1.ExplainVerbosity.executionStats,
-                    };
-                })];
-            _fetchShardKey_decorators = [op((0, logger_1.mongoLogId)(1_001_000_381))];
-            _indexes_decorators = [op((0, logger_1.mongoLogId)(1_001_000_047))];
-            _instance_decorators = [op((0, logger_1.mongoLogId)(1_001_000_024), (_, instanceData) => {
-                    if (instanceData) {
-                        return {
-                            serverVersion: instanceData.build.version,
-                            genuineMongoDB: instanceData.genuineMongoDB,
-                            dataLake: instanceData.dataLake,
-                            featureCompatibilityVersion: instanceData.featureCompatibilityVersion,
-                        };
+        }
+        configuredKMSProviders() {
+            return (0, instance_detail_helper_2.configuredKMSProviders)(this._connectionOptions.fleOptions?.autoEncryption);
+        }
+        _csfleLogInformation(fleOptions) {
+            const kmsProviders = (0, instance_detail_helper_2.configuredKMSProviders)(fleOptions?.autoEncryption);
+            if (kmsProviders.length === 0)
+                return null;
+            return {
+                storeCredentials: fleOptions?.storeCredentials,
+                encryptedFieldsMapNamespaces: Object.keys({
+                    ...fleOptions?.autoEncryption?.encryptedFieldsMap,
+                    ...fleOptions?.autoEncryption?.schemaMap,
+                }),
+                keyVaultNamespace: fleOptions?.autoEncryption?.keyVaultNamespace,
+                kmsProviders,
+            };
+        }
+        async createDataKey(provider, options) {
+            const clientEncryption = this._getClientEncryption();
+            return await clientEncryption.createDataKey(provider, options ?? {});
+        }
+        _getClientEncryption() {
+            const crudClient = this._initializedClient('CRUD');
+            const autoEncryptionOptions = crudClient.options.autoEncryption;
+            const { proxyHost, proxyPort, proxyUsername, proxyPassword } = crudClient.options;
+            return new mongodb_1.ClientEncryption(crudClient, {
+                keyVaultNamespace: autoEncryptionOptions.keyVaultNamespace,
+                kmsProviders: autoEncryptionOptions.kmsProviders,
+                tlsOptions: autoEncryptionOptions.tlsOptions,
+                proxyOptions: proxyHost
+                    ? {
+                        proxyHost,
+                        proxyPort,
+                        proxyUsername,
+                        proxyPassword,
                     }
-                })];
-            _insertOne_decorators = [op((0, logger_1.mongoLogId)(1_001_000_048), ([ns], result) => {
-                    return { ns, ...(result && { acknowledged: result.acknowledged }) };
-                })];
-            _insertMany_decorators = [op((0, logger_1.mongoLogId)(1_001_000_049), ([ns], result) => {
-                    return {
-                        ns,
-                        ...(result && {
-                            acknowledged: result.acknowledged,
-                            insertedCount: result.insertedCount,
-                        }),
-                    };
-                })];
-            _updateCollection_decorators = [op((0, logger_1.mongoLogId)(1_001_000_050), ([ns], result) => {
-                    return { ns, ...(result && { result }) };
-                })];
-            _currentOp_decorators = [op((0, logger_1.mongoLogId)(1_001_000_053))];
-            _serverStatus_decorators = [op((0, logger_1.mongoLogId)(1_001_000_061), (_, result) => {
-                    return result ? { result } : undefined;
-                })];
-            _top_decorators = [op((0, logger_1.mongoLogId)(1_001_000_062), (_, result) => {
-                    return result ? { result } : undefined;
-                })];
-            _createView_decorators = [op((0, logger_1.mongoLogId)(1_001_000_055), ([name, sourceNs, pipeline, options], result) => {
-                    return {
-                        name,
-                        sourceNs,
-                        stages: pipeline.map((stage) => Object.keys(stage)[0]),
-                        options,
-                        ...(result && { result }),
-                    };
-                })];
-            _databaseStats_decorators = [op((0, logger_1.mongoLogId)(1_001_000_057))];
-            _previewUpdate_decorators = [op((0, logger_1.mongoLogId)(1_001_000_266))];
-            _createDataKey_decorators = [op((0, logger_1.mongoLogId)(1_001_000_123), ([provider]) => {
-                    return { provider };
-                })];
-            _listStreamProcessors_decorators = [op((0, logger_1.mongoLogId)(1_001_000_284))];
-            _startStreamProcessor_decorators = [op((0, logger_1.mongoLogId)(1_001_000_285))];
-            _stopStreamProcessor_decorators = [op((0, logger_1.mongoLogId)(1_001_000_286))];
-            _dropStreamProcessor_decorators = [op((0, logger_1.mongoLogId)(1_001_000_287))];
-            __esDecorate(_a, null, _collectionStats_decorators, { kind: "method", name: "collectionStats", static: false, private: false, access: { has: obj => "collectionStats" in obj, get: obj => obj.collectionStats }, metadata: _metadata }, null, _instanceExtraInitializers);
-            __esDecorate(_a, null, _collectionInfo_decorators, { kind: "method", name: "collectionInfo", static: false, private: false, access: { has: obj => "collectionInfo" in obj, get: obj => obj.collectionInfo }, metadata: _metadata }, null, _instanceExtraInitializers);
-            __esDecorate(_a, null, _killOp_decorators, { kind: "method", name: "killOp", static: false, private: false, access: { has: obj => "killOp" in obj, get: obj => obj.killOp }, metadata: _metadata }, null, _instanceExtraInitializers);
-            __esDecorate(_a, null, __connectionStatus_decorators, { kind: "method", name: "_connectionStatus", static: false, private: false, access: { has: obj => "_connectionStatus" in obj, get: obj => obj._connectionStatus }, metadata: _metadata }, null, _instanceExtraInitializers);
-            __esDecorate(_a, null, _listCollections_decorators, { kind: "method", name: "listCollections", static: false, private: false, access: { has: obj => "listCollections" in obj, get: obj => obj.listCollections }, metadata: _metadata }, null, _instanceExtraInitializers);
-            __esDecorate(_a, null, _listDatabases_decorators, { kind: "method", name: "listDatabases", static: false, private: false, access: { has: obj => "listDatabases" in obj, get: obj => obj.listDatabases }, metadata: _metadata }, null, _instanceExtraInitializers);
-            __esDecorate(_a, null, _estimatedCount_decorators, { kind: "method", name: "estimatedCount", static: false, private: false, access: { has: obj => "estimatedCount" in obj, get: obj => obj.estimatedCount }, metadata: _metadata }, null, _instanceExtraInitializers);
-            __esDecorate(_a, null, _count_decorators, { kind: "method", name: "count", static: false, private: false, access: { has: obj => "count" in obj, get: obj => obj.count }, metadata: _metadata }, null, _instanceExtraInitializers);
-            __esDecorate(_a, null, _createCollection_decorators, { kind: "method", name: "createCollection", static: false, private: false, access: { has: obj => "createCollection" in obj, get: obj => obj.createCollection }, metadata: _metadata }, null, _instanceExtraInitializers);
-            __esDecorate(_a, null, _createIndex_decorators, { kind: "method", name: "createIndex", static: false, private: false, access: { has: obj => "createIndex" in obj, get: obj => obj.createIndex }, metadata: _metadata }, null, _instanceExtraInitializers);
-            __esDecorate(_a, null, _deleteOne_decorators, { kind: "method", name: "deleteOne", static: false, private: false, access: { has: obj => "deleteOne" in obj, get: obj => obj.deleteOne }, metadata: _metadata }, null, _instanceExtraInitializers);
-            __esDecorate(_a, null, _deleteMany_decorators, { kind: "method", name: "deleteMany", static: false, private: false, access: { has: obj => "deleteMany" in obj, get: obj => obj.deleteMany }, metadata: _metadata }, null, _instanceExtraInitializers);
-            __esDecorate(_a, null, _dropCollection_decorators, { kind: "method", name: "dropCollection", static: false, private: false, access: { has: obj => "dropCollection" in obj, get: obj => obj.dropCollection }, metadata: _metadata }, null, _instanceExtraInitializers);
-            __esDecorate(_a, null, _renameCollection_decorators, { kind: "method", name: "renameCollection", static: false, private: false, access: { has: obj => "renameCollection" in obj, get: obj => obj.renameCollection }, metadata: _metadata }, null, _instanceExtraInitializers);
-            __esDecorate(_a, null, _dropDatabase_decorators, { kind: "method", name: "dropDatabase", static: false, private: false, access: { has: obj => "dropDatabase" in obj, get: obj => obj.dropDatabase }, metadata: _metadata }, null, _instanceExtraInitializers);
-            __esDecorate(_a, null, _dropIndex_decorators, { kind: "method", name: "dropIndex", static: false, private: false, access: { has: obj => "dropIndex" in obj, get: obj => obj.dropIndex }, metadata: _metadata }, null, _instanceExtraInitializers);
-            __esDecorate(_a, null, _isListSearchIndexesSupported_decorators, { kind: "method", name: "isListSearchIndexesSupported", static: false, private: false, access: { has: obj => "isListSearchIndexesSupported" in obj, get: obj => obj.isListSearchIndexesSupported }, metadata: _metadata }, null, _instanceExtraInitializers);
-            __esDecorate(_a, null, _getSearchIndexes_decorators, { kind: "method", name: "getSearchIndexes", static: false, private: false, access: { has: obj => "getSearchIndexes" in obj, get: obj => obj.getSearchIndexes }, metadata: _metadata }, null, _instanceExtraInitializers);
-            __esDecorate(_a, null, _createSearchIndex_decorators, { kind: "method", name: "createSearchIndex", static: false, private: false, access: { has: obj => "createSearchIndex" in obj, get: obj => obj.createSearchIndex }, metadata: _metadata }, null, _instanceExtraInitializers);
-            __esDecorate(_a, null, _updateSearchIndex_decorators, { kind: "method", name: "updateSearchIndex", static: false, private: false, access: { has: obj => "updateSearchIndex" in obj, get: obj => obj.updateSearchIndex }, metadata: _metadata }, null, _instanceExtraInitializers);
-            __esDecorate(_a, null, _dropSearchIndex_decorators, { kind: "method", name: "dropSearchIndex", static: false, private: false, access: { has: obj => "dropSearchIndex" in obj, get: obj => obj.dropSearchIndex }, metadata: _metadata }, null, _instanceExtraInitializers);
-            __esDecorate(_a, null, _aggregateCursor_decorators, { kind: "method", name: "aggregateCursor", static: false, private: false, access: { has: obj => "aggregateCursor" in obj, get: obj => obj.aggregateCursor }, metadata: _metadata }, null, _instanceExtraInitializers);
-            __esDecorate(_a, null, _aggregate_decorators, { kind: "method", name: "aggregate", static: false, private: false, access: { has: obj => "aggregate" in obj, get: obj => obj.aggregate }, metadata: _metadata }, null, _instanceExtraInitializers);
-            __esDecorate(_a, null, _find_decorators, { kind: "method", name: "find", static: false, private: false, access: { has: obj => "find" in obj, get: obj => obj.find }, metadata: _metadata }, null, _instanceExtraInitializers);
-            __esDecorate(_a, null, _findCursor_decorators, { kind: "method", name: "findCursor", static: false, private: false, access: { has: obj => "findCursor" in obj, get: obj => obj.findCursor }, metadata: _metadata }, null, _instanceExtraInitializers);
-            __esDecorate(_a, null, _findOneAndReplace_decorators, { kind: "method", name: "findOneAndReplace", static: false, private: false, access: { has: obj => "findOneAndReplace" in obj, get: obj => obj.findOneAndReplace }, metadata: _metadata }, null, _instanceExtraInitializers);
-            __esDecorate(_a, null, _findOneAndUpdate_decorators, { kind: "method", name: "findOneAndUpdate", static: false, private: false, access: { has: obj => "findOneAndUpdate" in obj, get: obj => obj.findOneAndUpdate }, metadata: _metadata }, null, _instanceExtraInitializers);
-            __esDecorate(_a, null, _updateOne_decorators, { kind: "method", name: "updateOne", static: false, private: false, access: { has: obj => "updateOne" in obj, get: obj => obj.updateOne }, metadata: _metadata }, null, _instanceExtraInitializers);
-            __esDecorate(_a, null, _replaceOne_decorators, { kind: "method", name: "replaceOne", static: false, private: false, access: { has: obj => "replaceOne" in obj, get: obj => obj.replaceOne }, metadata: _metadata }, null, _instanceExtraInitializers);
-            __esDecorate(_a, null, _explainFind_decorators, { kind: "method", name: "explainFind", static: false, private: false, access: { has: obj => "explainFind" in obj, get: obj => obj.explainFind }, metadata: _metadata }, null, _instanceExtraInitializers);
-            __esDecorate(_a, null, _explainAggregate_decorators, { kind: "method", name: "explainAggregate", static: false, private: false, access: { has: obj => "explainAggregate" in obj, get: obj => obj.explainAggregate }, metadata: _metadata }, null, _instanceExtraInitializers);
-            __esDecorate(_a, null, _fetchShardKey_decorators, { kind: "method", name: "fetchShardKey", static: false, private: false, access: { has: obj => "fetchShardKey" in obj, get: obj => obj.fetchShardKey }, metadata: _metadata }, null, _instanceExtraInitializers);
-            __esDecorate(_a, null, _indexes_decorators, { kind: "method", name: "indexes", static: false, private: false, access: { has: obj => "indexes" in obj, get: obj => obj.indexes }, metadata: _metadata }, null, _instanceExtraInitializers);
-            __esDecorate(_a, null, _instance_decorators, { kind: "method", name: "instance", static: false, private: false, access: { has: obj => "instance" in obj, get: obj => obj.instance }, metadata: _metadata }, null, _instanceExtraInitializers);
-            __esDecorate(_a, null, _insertOne_decorators, { kind: "method", name: "insertOne", static: false, private: false, access: { has: obj => "insertOne" in obj, get: obj => obj.insertOne }, metadata: _metadata }, null, _instanceExtraInitializers);
-            __esDecorate(_a, null, _insertMany_decorators, { kind: "method", name: "insertMany", static: false, private: false, access: { has: obj => "insertMany" in obj, get: obj => obj.insertMany }, metadata: _metadata }, null, _instanceExtraInitializers);
-            __esDecorate(_a, null, _updateCollection_decorators, { kind: "method", name: "updateCollection", static: false, private: false, access: { has: obj => "updateCollection" in obj, get: obj => obj.updateCollection }, metadata: _metadata }, null, _instanceExtraInitializers);
-            __esDecorate(_a, null, _currentOp_decorators, { kind: "method", name: "currentOp", static: false, private: false, access: { has: obj => "currentOp" in obj, get: obj => obj.currentOp }, metadata: _metadata }, null, _instanceExtraInitializers);
-            __esDecorate(_a, null, _serverStatus_decorators, { kind: "method", name: "serverStatus", static: false, private: false, access: { has: obj => "serverStatus" in obj, get: obj => obj.serverStatus }, metadata: _metadata }, null, _instanceExtraInitializers);
-            __esDecorate(_a, null, _top_decorators, { kind: "method", name: "top", static: false, private: false, access: { has: obj => "top" in obj, get: obj => obj.top }, metadata: _metadata }, null, _instanceExtraInitializers);
-            __esDecorate(_a, null, _createView_decorators, { kind: "method", name: "createView", static: false, private: false, access: { has: obj => "createView" in obj, get: obj => obj.createView }, metadata: _metadata }, null, _instanceExtraInitializers);
-            __esDecorate(_a, null, _databaseStats_decorators, { kind: "method", name: "databaseStats", static: false, private: false, access: { has: obj => "databaseStats" in obj, get: obj => obj.databaseStats }, metadata: _metadata }, null, _instanceExtraInitializers);
-            __esDecorate(_a, null, _previewUpdate_decorators, { kind: "method", name: "previewUpdate", static: false, private: false, access: { has: obj => "previewUpdate" in obj, get: obj => obj.previewUpdate }, metadata: _metadata }, null, _instanceExtraInitializers);
-            __esDecorate(_a, null, _createDataKey_decorators, { kind: "method", name: "createDataKey", static: false, private: false, access: { has: obj => "createDataKey" in obj, get: obj => obj.createDataKey }, metadata: _metadata }, null, _instanceExtraInitializers);
-            __esDecorate(_a, null, _listStreamProcessors_decorators, { kind: "method", name: "listStreamProcessors", static: false, private: false, access: { has: obj => "listStreamProcessors" in obj, get: obj => obj.listStreamProcessors }, metadata: _metadata }, null, _instanceExtraInitializers);
-            __esDecorate(_a, null, _startStreamProcessor_decorators, { kind: "method", name: "startStreamProcessor", static: false, private: false, access: { has: obj => "startStreamProcessor" in obj, get: obj => obj.startStreamProcessor }, metadata: _metadata }, null, _instanceExtraInitializers);
-            __esDecorate(_a, null, _stopStreamProcessor_decorators, { kind: "method", name: "stopStreamProcessor", static: false, private: false, access: { has: obj => "stopStreamProcessor" in obj, get: obj => obj.stopStreamProcessor }, metadata: _metadata }, null, _instanceExtraInitializers);
-            __esDecorate(_a, null, _dropStreamProcessor_decorators, { kind: "method", name: "dropStreamProcessor", static: false, private: false, access: { has: obj => "dropStreamProcessor" in obj, get: obj => obj.dropStreamProcessor }, metadata: _metadata }, null, _instanceExtraInitializers);
-            if (_metadata) Object.defineProperty(_a, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
-        })(),
-        (() => {
-            const assertNoExtraProps = (
-            // eslint-disable-next-line @typescript-eslint/no-unused-vars
-            _cls) => {
+                    : undefined,
+            });
+        }
+        async getUpdatedSecrets() {
+            if (!this._state)
+                return {};
+            return {
+                oidc: {
+                    serializedState: await this._state.oidcPlugin.serialize(),
+                },
+            };
+        }
+        async listStreamProcessors(filter) {
+            const adminDb = this._database('admin', 'CRUD');
+            const { streamProcessors } = await (0, run_command_1.runCommand)(adminDb, {
+                listStreamProcessors: 1,
+                filter,
+            });
+            return streamProcessors;
+        }
+        async startStreamProcessor(name) {
+            const adminDb = this._database('admin', 'CRUD');
+            await (0, run_command_1.runCommand)(adminDb, { startStreamProcessor: name });
+        }
+        async stopStreamProcessor(name) {
+            const adminDb = this._database('admin', 'CRUD');
+            await (0, run_command_1.runCommand)(adminDb, { stopStreamProcessor: name });
+        }
+        async dropStreamProcessor(name) {
+            const adminDb = this._database('admin', 'CRUD');
+            await (0, run_command_1.runCommand)(adminDb, { dropStreamProcessor: name });
+        }
+        static {
+            const assertNoExtraProps = (_cls) => {
                 // Checking that we are not exposing anything unexpected on our data service
                 // implementation. This file will not compile if there are more public methods
                 // on the DataServiceImpl than DataService interface allows
             };
-            assertNoExtraProps(_a);
-        })(),
-        _a;
+            assertNoExtraProps(this);
+        }
+    };
 })();
 exports.DataServiceImpl = DataServiceImpl;
 function isTransactionAbortError(err) {