mongodb-data-service 21.10.0 → 21.14.0

package/lib/data-service.js

@@ -2,165 +2,874 @@
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
+Object.defineProperty(exports, "__esModule", { value: true });
+const util_1 = require("util");
+const async_1 = __importDefault(require("async"));
+const compass_logging_1 = __importDefault(require("@mongodb-js/compass-logging"));
 const events_1 = require("events");
-const native_client_1 = __importDefault(require("./native-client"));
+const lodash_1 = require("lodash");
+const mongodb_connection_string_url_1 = __importDefault(require("mongodb-connection-string-url"));
+const instance_detail_helper_1 = require("./instance-detail-helper");
+const redact_1 = require("./redact");
+const connect_mongo_client_1 = __importDefault(require("./connect-mongo-client"));
+const get_port_1 = __importDefault(require("get-port"));
+const run_command_1 = require("./run-command");
+const { fetch: getIndexes } = require('mongodb-index-model');
+const parseNamespace = require('mongodb-ns');
+const { log, mongoLogId, debug } = compass_logging_1.default('COMPASS-DATA-SERVICE');
+function uniqueBy(values, key) {
+    return Array.from(new Map(values.map((val) => [val[key], val])).values());
+}
+let id = 0;
 class DataService extends events_1.EventEmitter {
-    constructor(model) {
+    constructor(connectionOptions) {
         super();
-        this.lastSeenTopology = null;
-        this.client = new native_client_1.default(model)
-            .on('status', (evt) => this.emit('status', evt))
-            .on('serverDescriptionChanged', (evt) => this.emit('serverDescriptionChanged', evt))
-            .on('serverOpening', (evt) => this.emit('serverOpening', evt))
-            .on('serverClosed', (evt) => this.emit('serverClosed', evt))
-            .on('topologyOpening', (evt) => this.emit('topologyOpening', evt))
-            .on('topologyClosed', (evt) => this.emit('topologyClosed', evt))
-            .on('topologyDescriptionChanged', (evt) => {
-            this.lastSeenTopology = evt.newDescription;
-            this.emit('topologyDescriptionChanged', evt);
-        });
+        this._isConnecting = false;
+        this._lastSeenTopology = null;
+        this._isWritable = false;
+        this._isMongos = false;
+        this._id = id++;
+        this._connectionOptions = connectionOptions;
+    }
+    getMongoClientConnectionOptions() {
+        return this._mongoClientConnectionOptions;
+    }
+    _logCtx() {
+        return `Connection ${this._id}`;
     }
     getConnectionOptions() {
-        return this.client.connectionOptions;
+        return this._connectionOptions;
+    }
+    getConnectionString() {
+        return new mongodb_connection_string_url_1.default(this._connectionOptions.connectionString);
+    }
+    getReadPreference() {
+        return this._initializedClient.readPreference;
     }
     collection(ns, options, callback) {
-        this.client.collectionDetail(ns, callback);
+        async_1.default.parallel({
+            stats: this.collectionStats.bind(this, this._databaseName(ns), this._collectionName(ns)),
+            indexes: this.indexes.bind(this, ns, options),
+        }, (error, coll) => {
+            if (error) {
+                return callback(this._translateMessage(error));
+            }
+            callback(null, this._buildCollectionDetail(ns, coll));
+        });
+    }
+    collections(databaseName, callback) {
+        if (databaseName === 'system') {
+            return callback(null, []);
+        }
+        this._collectionNames(databaseName, (error, names) => {
+            if (error) {
+                return callback(this._translateMessage(error));
+            }
+            async_1.default.parallel((names || []).map((name) => {
+                return (done) => {
+                    this.collectionStats(databaseName, name, done);
+                };
+            }), callback);
+        });
     }
     collectionStats(databaseName, collectionName, callback) {
-        this.client.collectionStats(databaseName, collectionName, callback);
+        const logop = this._startLogOp(mongoLogId(1001000031), 'Fetching collection info', { ns: `${databaseName}.${collectionName}` });
+        const db = this._initializedClient.db(databaseName);
+        db.command({ collStats: collectionName, verbose: true }, (error, data) => {
+            logop(error);
+            if (error && !error.message.includes('is a view, not a collection')) {
+                return callback(this._translateMessage(error));
+            }
+            callback(null, this._buildCollectionStats(databaseName, collectionName, data || {}));
+        });
+    }
+    async collectionInfo(dbName, collName) {
+        try {
+            const [collInfo] = await this.listCollections(dbName, { name: collName });
+            return collInfo !== null && collInfo !== void 0 ? collInfo : null;
+        }
+        catch (err) {
+            throw this._translateMessage(err);
+        }
     }
     command(databaseName, comm, callback) {
-        this.client.command(databaseName, comm, callback);
+        const db = this._initializedClient.db(databaseName);
+        db.command(comm, (error, result) => {
+            if (error) {
+                return callback(this._translateMessage(error));
+            }
+            callback(null, result);
+        });
     }
     isWritable() {
-        return this.client.isWritable;
+        return this._isWritable;
     }
     isMongos() {
-        return this.client.isMongos;
-    }
-    listCollections(databaseName, filter, callback) {
-        this.client.listCollections(databaseName, filter, callback);
-    }
-    listDatabases(callback) {
-        this.client.listDatabases(callback);
-    }
-    connect(done) {
-        this.client.connect((err) => {
-            if (err) {
-                return done(err);
+        return this._isMongos;
+    }
+    async connectionStatus() {
+        const logop = this._startLogOp(mongoLogId(1001000100), 'Running connectionStatus');
+        try {
+            const adminDb = this._initializedClient.db('admin');
+            const result = await run_command_1.runCommand(adminDb, {
+                connectionStatus: 1,
+                showPrivileges: true,
+            });
+            logop(null);
+            return result;
+        }
+        catch (e) {
+            logop(e);
+            throw e;
+        }
+    }
+    async _getPrivilegesOrFallback(privileges = null) {
+        if (privileges) {
+            return privileges;
+        }
+        const { authInfo: { authenticatedUserPrivileges }, } = await this.connectionStatus();
+        return authenticatedUserPrivileges;
+    }
+    async listCollections(databaseName, filter = {}, { nameOnly, privileges = null, } = {}) {
+        const logop = this._startLogOp(mongoLogId(1001000032), 'Running listCollections', { db: databaseName, nameOnly: nameOnly !== null && nameOnly !== void 0 ? nameOnly : false });
+        const db = this._initializedClient.db(databaseName);
+        const listCollections = async () => {
+            try {
+                return await db.listCollections(filter, { nameOnly }).toArray();
+            }
+            catch (err) {
+                log.warn(mongoLogId(1001000099), this._logCtx(), 'Failed to run listCollections', { message: err.message });
+                return [];
+            }
+        };
+        const getCollectionsFromPrivileges = async () => {
+            const databases = instance_detail_helper_1.getPrivilegesByDatabaseAndCollection(await this._getPrivilegesOrFallback(privileges), ['find']);
+            return Object.keys(databases[databaseName] || {})
+                .filter(Boolean)
+                .map((name) => ({ name }));
+        };
+        try {
+            const [listedCollections, collectionsFromPrivileges] = await Promise.all([
+                listCollections(),
+                getCollectionsFromPrivileges(),
+            ]);
+            const collections = uniqueBy([...collectionsFromPrivileges, ...listedCollections], 'name').map((coll) => instance_detail_helper_1.adaptCollectionInfo({ db: databaseName, ...coll }));
+            logop(null, { collectionsCount: collections.length });
+            return collections;
+        }
+        catch (err) {
+            logop(err);
+            throw err;
+        }
+    }
+    async listDatabases({ nameOnly, privileges = null, } = {}) {
+        const logop = this._startLogOp(mongoLogId(1001000033), 'Running listDatabases', { nameOnly: nameOnly !== null && nameOnly !== void 0 ? nameOnly : false });
+        const adminDb = this._initializedClient.db('admin');
+        const listDatabases = async () => {
+            try {
+                const { databases } = await run_command_1.runCommand(adminDb, {
+                    listDatabases: 1,
+                    nameOnly,
+                });
+                return databases;
             }
-            done(null, this);
-            this.emit('readable');
+            catch (err) {
+                log.warn(mongoLogId(1001000098), this._logCtx(), 'Failed to run listDatabases', { message: err.message });
+                return [];
+            }
+        };
+        const getDatabasesFromPrivileges = async () => {
+            const databases = instance_detail_helper_1.getPrivilegesByDatabaseAndCollection(await this._getPrivilegesOrFallback(privileges), ['find']);
+            return Object.keys(databases)
+                .filter(Boolean)
+                .map((name) => ({ name }));
+        };
+        try {
+            const [listedDatabases, databasesFromPrivileges] = await Promise.all([
+                listDatabases(),
+                getDatabasesFromPrivileges(),
+            ]);
+            const databases = uniqueBy([...databasesFromPrivileges, ...listedDatabases], 'name').map((db) => instance_detail_helper_1.adaptDatabaseInfo({ db: db.name, ...db }));
+            logop(null, { databasesCount: databases.length });
+            return databases;
+        }
+        catch (err) {
+            logop(err);
+            throw err;
+        }
+    }
+    async connect() {
+        if (this._client) {
+            debug('already connected');
+            return;
+        }
+        if (this._isConnecting) {
+            debug('connect method called more than once');
+            return;
+        }
+        debug('connecting...');
+        this._isConnecting = true;
+        log.info(mongoLogId(1001000014), this._logCtx(), 'Connecting', {
+            url: redact_1.redactConnectionString(this._connectionOptions.connectionString),
         });
+        try {
+            const tunnelLocalPort = this._connectionOptions.sshTunnel
+                ? await get_port_1.default()
+                : 0;
+            const [client, tunnel, connectionOptions] = await connect_mongo_client_1.default(this._connectionOptions, this.setupListeners.bind(this), tunnelLocalPort);
+            const attr = {
+                isWritable: this.isWritable(),
+                isMongos: this.isMongos(),
+            };
+            log.info(mongoLogId(1001000015), this._logCtx(), 'Connected', attr);
+            debug('connected!', attr);
+            this._client = client;
+            this._tunnel = tunnel;
+            this._mongoClientConnectionOptions = connectionOptions;
+        }
+        finally {
+            this._isConnecting = false;
+        }
     }
     estimatedCount(ns, options, callback) {
-        this.client.estimatedCount(ns, options, callback);
+        const logop = this._startLogOp(mongoLogId(1001000034), 'Running estimatedCount', { ns });
+        this._collection(ns).estimatedDocumentCount(options, (err, result) => {
+            logop(err, result);
+            callback(err, result);
+        });
     }
     count(ns, filter, options, callback) {
-        this.client.count(ns, filter, options, callback);
+        const logop = this._startLogOp(mongoLogId(1001000035), 'Running countDocuments', { ns });
+        this._collection(ns).countDocuments(filter, options, (err, result) => {
+            logop(err, result);
+            callback(err, result);
+        });
     }
     createCollection(ns, options, callback) {
-        this.client.createCollection(ns, options, callback);
+        const collectionName = this._collectionName(ns);
+        const db = this._initializedClient.db(this._databaseName(ns));
+        const logop = this._startLogOp(mongoLogId(1001000036), 'Running createCollection', { ns, options });
+        db.createCollection(collectionName, options, (error, result) => {
+            logop(error);
+            if (error) {
+                return callback(this._translateMessage(error));
+            }
+            callback(null, result);
+        });
     }
     createIndex(ns, spec, options, callback) {
-        this.client.createIndex(ns, spec, options, callback);
+        const logop = this._startLogOp(mongoLogId(1001000037), 'Running createIndex', { ns, spec, options });
+        this._collection(ns).createIndex(spec, options, (error, result) => {
+            logop(error);
+            if (error) {
+                return callback(this._translateMessage(error));
+            }
+            callback(null, result);
+        });
     }
     database(name, options, callback) {
-        this.client.databaseDetail(name, callback);
+        const asyncColls = util_1.promisify(this.collections.bind(this));
+        void Promise.all([this.databaseStats(name), asyncColls(name)]).then(([stats, collections]) => {
+            callback(null, this._buildDatabaseDetail(name, { stats, collections }));
+        }, (err) => {
+            callback(this._translateMessage(err));
+        });
     }
     deleteOne(ns, filter, options, callback) {
-        this.client.deleteOne(ns, filter, options, callback);
+        const logop = this._startLogOp(mongoLogId(1001000038), 'Running deleteOne', { ns });
+        this._collection(ns).deleteOne(filter, options, (error, result) => {
+            logop(error, result);
+            if (error) {
+                return callback(this._translateMessage(error));
+            }
+            callback(null, result);
+        });
     }
     deleteMany(ns, filter, options, callback) {
-        this.client.deleteMany(ns, filter, options, callback);
+        const logop = this._startLogOp(mongoLogId(1001000039), 'Running deleteMany', { ns });
+        this._collection(ns).deleteMany(filter, options, (error, result) => {
+            logop(error, result);
+            if (error) {
+                return callback(this._translateMessage(error));
+            }
+            callback(null, result);
+        });
     }
-    disconnect(callback) {
-        this.client.disconnect(callback);
+    async disconnect() {
+        var _a, _b;
+        log.info(mongoLogId(1001000016), this._logCtx(), 'Disconnecting');
+        try {
+            await ((_a = this._client) === null || _a === void 0 ? void 0 : _a.close(true).catch((err) => debug('failed to close MongoClient', err)));
+            await ((_b = this._tunnel) === null || _b === void 0 ? void 0 : _b.close().catch((err) => debug('failed to close tunnel', err)));
+        }
+        finally {
+            this._cleanup();
+            log.info(mongoLogId(1001000017), this._logCtx(), 'Fully closed');
+        }
     }
     dropCollection(ns, callback) {
-        this.client.dropCollection(ns, callback);
+        const logop = this._startLogOp(mongoLogId(1001000059), 'Running dropCollection', { ns });
+        this._collection(ns).drop((error, result) => {
+            logop(error, result);
+            if (error) {
+                return callback(this._translateMessage(error));
+            }
+            callback(null, result);
+        });
     }
     dropDatabase(name, callback) {
-        this.client.dropDatabase(name, callback);
+        const logop = this._startLogOp(mongoLogId(1001000040), 'Running dropDatabase', { db: name });
+        this._initializedClient
+            .db(this._databaseName(name))
+            .dropDatabase((error, result) => {
+            logop(error, result);
+            if (error) {
+                return callback(this._translateMessage(error));
+            }
+            callback(null, result);
+        });
     }
     dropIndex(ns, name, callback) {
-        this.client.dropIndex(ns, name, callback);
+        const logop = this._startLogOp(mongoLogId(1001000060), 'Running dropIndex', { ns, name });
+        this._collection(ns).dropIndex(name, (error, result) => {
+            logop(error, result);
+            if (error) {
+                return callback(this._translateMessage(error));
+            }
+            callback(null, result);
+        });
     }
     aggregate(ns, pipeline, options, callback) {
-        return this.client.aggregate(ns, pipeline, options, callback);
+        log.info(mongoLogId(1001000041), this._logCtx(), 'Running aggregation', {
+            ns,
+            stages: pipeline.map((stage) => Object.keys(stage)[0]),
+        });
+        if (typeof options === 'function') {
+            callback = options;
+            options = undefined;
+        }
+        const cursor = this._collection(ns).aggregate(pipeline, options);
+        if (lodash_1.isFunction(callback)) {
+            process.nextTick(callback, null, cursor);
+            return;
+        }
+        return cursor;
     }
     find(ns, filter, options, callback) {
-        this.client.find(ns, filter, options, callback);
+        const logop = this._startLogOp(mongoLogId(1001000042), 'Running find', {
+            ns,
+        });
+        const cursor = this._collection(ns).find(filter, options);
+        cursor.toArray((error, documents) => {
+            logop(error);
+            if (error) {
+                return callback(this._translateMessage(error));
+            }
+            callback(null, documents);
+        });
     }
     fetch(ns, filter, options) {
-        return this.client.fetch(ns, filter, options);
+        const logop = this._startLogOp(mongoLogId(1001000043), 'Running raw find', { ns });
+        return this._collection(ns).find(filter, options);
     }
     findOneAndReplace(ns, filter, replacement, options, callback) {
-        this.client.findOneAndReplace(ns, filter, replacement, options, callback);
+        const logop = this._startLogOp(mongoLogId(1001000044), 'Running findOneAndReplace', { ns });
+        this._collection(ns).findOneAndReplace(filter, replacement, options, (error, result) => {
+            logop(error);
+            if (error) {
+                return callback(this._translateMessage(error));
+            }
+            callback(null, result.value);
+        });
     }
     findOneAndUpdate(ns, filter, update, options, callback) {
-        this.client.findOneAndUpdate(ns, filter, update, options, callback);
+        const logop = this._startLogOp(mongoLogId(1001000045), 'Running findOneAndUpdate', { ns });
+        this._collection(ns).findOneAndUpdate(filter, update, options, (error, result) => {
+            logop(error);
+            if (error) {
+                return callback(this._translateMessage(error));
+            }
+            callback(null, result.value);
+        });
     }
     explain(ns, filter, options, callback) {
-        this.client.explain(ns, filter, options, callback);
+        const logop = this._startLogOp(mongoLogId(1001000046), 'Running find explain', { ns });
+        this._collection(ns)
+            .find(filter, options)
+            .explain((error, explanation) => {
+            logop(error);
+            if (error) {
+                return callback(this._translateMessage(error));
+            }
+            callback(null, explanation);
+        });
     }
     indexes(ns, options, callback) {
-        this.client.indexes(ns, callback);
+        const logop = this._startLogOp(mongoLogId(1001000047), 'Listing indexes', { ns });
+        getIndexes(this._initializedClient, ns, (error, data) => {
+            logop(error);
+            if (error) {
+                return callback(this._translateMessage(error));
+            }
+            callback(null, data);
+        });
     }
-    instance(options, callback) {
-        this.client.instance(callback);
+    async instance() {
+        try {
+            const instanceData = await instance_detail_helper_1.getInstance(this._initializedClient);
+            log.info(mongoLogId(1001000024), this._logCtx(), 'Fetched instance information', {
+                serverVersion: instanceData.build.version,
+                genuineMongoDB: instanceData.genuineMongoDB,
+                dataLake: instanceData.dataLake,
+                featureCompatibilityVersion: instanceData.featureCompatibilityVersion,
+            });
+            return instanceData;
+        }
+        catch (err) {
+            throw this._translateMessage(err);
+        }
     }
     insertOne(ns, doc, options, callback) {
-        this.client.insertOne(ns, doc, options, callback);
+        const logop = this._startLogOp(mongoLogId(1001000048), 'Running insertOne', { ns });
+        this._collection(ns).insertOne(doc, options, (error, result) => {
+            logop(error, { acknowledged: result === null || result === void 0 ? void 0 : result.acknowledged });
+            if (error) {
+                return callback(this._translateMessage(error));
+            }
+            callback(null, result);
+        });
     }
     insertMany(ns, docs, options, callback) {
-        this.client.insertMany(ns, docs, options, callback);
+        const logop = this._startLogOp(mongoLogId(1001000049), 'Running insertOne', { ns });
+        this._collection(ns).insertMany(docs, options, (error, result) => {
+            logop(error, {
+                acknowledged: result === null || result === void 0 ? void 0 : result.acknowledged,
+                insertedCount: result === null || result === void 0 ? void 0 : result.insertedCount,
+            });
+            if (error) {
+                return callback(this._translateMessage(error));
+            }
+            callback(null, result);
+        });
     }
     putMany(ns, docs, options) {
-        return this.client.putMany(ns, docs, options);
+        return this._collection(ns).insertMany(docs, options);
     }
     updateCollection(ns, flags, callback) {
-        this.client.updateCollection(ns, flags, callback);
+        const logop = this._startLogOp(mongoLogId(1001000050), 'Running updateCollection', { ns });
+        const collectionName = this._collectionName(ns);
+        const db = this._initializedClient.db(this._databaseName(ns));
+        const command = {
+            collMod: collectionName,
+            ...flags,
+        };
+        db.command(command, (error, result) => {
+            logop(error, result);
+            if (error) {
+                return callback(this._translateMessage(error));
+            }
+            callback(null, result);
+        });
     }
     updateOne(ns, filter, update, options, callback) {
-        this.client.updateOne(ns, filter, update, options, callback);
+        const logop = this._startLogOp(mongoLogId(1001000051), 'Running updateOne', { ns });
+        this._collection(ns).updateOne(filter, update, options, (error, result) => {
+            logop(error, result);
+            if (error) {
+                return callback(this._translateMessage(error));
+            }
+            callback(null, result);
+        });
     }
     updateMany(ns, filter, update, options, callback) {
-        this.client.updateMany(ns, filter, update, options, callback);
+        const logop = this._startLogOp(mongoLogId(1001000052), 'Running updateMany', { ns });
+        this._collection(ns).updateMany(filter, update, options, (error, result) => {
+            logop(error, result);
+            if (error) {
+                return callback(this._translateMessage(error));
+            }
+            callback(null, result);
+        });
     }
     currentOp(includeAll, callback) {
-        this.client.currentOp(includeAll, callback);
+        const logop = this._startLogOp(mongoLogId(1001000053), 'Running currentOp');
+        this._initializedClient
+            .db('admin')
+            .command({ currentOp: 1, $all: includeAll }, (error, result) => {
+            logop(error);
+            if (error) {
+                const logop = this._startLogOp(mongoLogId(1001000054), 'Searching $cmd.sys.inprog manually');
+                this._initializedClient
+                    .db('admin')
+                    .collection('$cmd.sys.inprog')
+                    .findOne({ $all: includeAll }, (error2, result2) => {
+                    logop(error2);
+                    if (error2) {
+                        return callback(this._translateMessage(error2));
+                    }
+                    callback(null, result2);
+                });
+                return;
+            }
+            callback(null, result);
+        });
     }
     getLastSeenTopology() {
-        return this.lastSeenTopology;
+        return this._lastSeenTopology;
     }
     serverstats(callback) {
-        this.client.serverStats(callback);
+        const logop = this._startLogOp(mongoLogId(1001000061), 'Running serverStats');
+        this._defaultDb.admin().serverStatus((error, result) => {
+            logop(error);
+            if (error) {
+                return callback(this._translateMessage(error));
+            }
+            callback(null, result);
+        });
     }
     top(callback) {
-        this.client.top(callback);
+        const logop = this._startLogOp(mongoLogId(1001000062), 'Running top');
+        this._defaultDb.admin().command({ top: 1 }, (error, result) => {
+            logop(error);
+            if (error) {
+                return callback(this._translateMessage(error));
+            }
+            callback(null, result);
+        });
     }
     createView(name, sourceNs, pipeline, options, callback) {
-        this.client.createView(name, sourceNs, pipeline, options, callback);
+        options.viewOn = this._collectionName(sourceNs);
+        options.pipeline = pipeline;
+        const logop = this._startLogOp(mongoLogId(1001000055), 'Running createView', {
+            name,
+            sourceNs,
+            stages: pipeline.map((stage) => Object.keys(stage)[0]),
+            options,
+        });
+        this._initializedClient
+            .db(this._databaseName(sourceNs))
+            .createCollection(name, options, (error, result) => {
+            logop(error, result);
+            if (error) {
+                return callback(this._translateMessage(error));
+            }
+            callback(null, result);
+        });
     }
     updateView(name, sourceNs, pipeline, options, callback) {
-        this.client.updateView(name, sourceNs, pipeline, options, callback);
+        options.viewOn = this._collectionName(sourceNs);
+        options.pipeline = pipeline;
+        const command = {
+            collMod: name,
+            ...options,
+        };
+        const db = this._initializedClient.db(this._databaseName(sourceNs));
+        const logop = this._startLogOp(mongoLogId(1001000056), 'Running updateView', {
+            name,
+            sourceNs,
+            stages: pipeline.map((stage) => Object.keys(stage)[0]),
+            options,
+        });
+        db.command(command, (error, result) => {
+            logop(error, result);
+            if (error) {
+                return callback(this._translateMessage(error));
+            }
+            callback(null, result);
+        });
     }
     dropView(ns, callback) {
-        this.client.dropView(ns, callback);
-    }
-    sample(ns, args = {}, options = {}) {
-        return this.client.sample(ns, args, options);
+        this.dropCollection(ns, callback);
+    }
+    sample(ns, { query, size, fields, } = {}, options = {}) {
+        const pipeline = [];
+        if (query && Object.keys(query).length > 0) {
+            pipeline.push({
+                $match: query,
+            });
+        }
+        pipeline.push({
+            $sample: {
+                size: size === 0 ? 0 : size || 1000,
+            },
+        });
+        if (fields && Object.keys(fields).length > 0) {
+            pipeline.push({
+                $project: fields,
+            });
+        }
+        return this.aggregate(ns, pipeline, {
+            allowDiskUse: true,
+            ...options,
+        });
     }
     startSession() {
-        return this.client.startSession();
+        return this._initializedClient.startSession();
     }
-    killSession(session) {
-        return this.client.killSession(session);
+    killSessions(sessions) {
+        return this._initializedClient.db('admin').command({
+            killSessions: Array.isArray(sessions)
+                ? sessions.map((s) => s.id)
+                : [sessions.id],
+        });
     }
     isConnected() {
-        return this.client.isConnected();
+        return !!this._client;
+    }
+    setupListeners(client) {
+        this._client = client;
+        if (client) {
+            client.on('serverDescriptionChanged', (evt) => {
+                var _a;
+                log.info(mongoLogId(1001000018), this._logCtx(), 'Server description changed', {
+                    address: evt.address,
+                    error: (_a = evt.newDescription.error) !== null && _a !== void 0 ? _a : null,
+                    previousType: evt.previousDescription.type,
+                    newType: evt.newDescription.type,
+                });
+                this.emit('serverDescriptionChanged', evt);
+            });
+            client.on('serverOpening', (evt) => {
+                log.info(mongoLogId(1001000019), this._logCtx(), 'Server opening', {
+                    address: evt.address,
+                });
+                this.emit('serverOpening', evt);
+            });
+            client.on('serverClosed', (evt) => {
+                log.info(mongoLogId(1001000020), this._logCtx(), 'Server closed', {
+                    address: evt.address,
+                });
+                this.emit('serverClosed', evt);
+            });
+            client.on('topologyOpening', (evt) => {
+                this.emit('topologyOpening', evt);
+            });
+            client.on('topologyClosed', (evt) => {
+                this.emit('topologyClosed', evt);
+            });
+            client.on('topologyDescriptionChanged', (evt) => {
+                this._isWritable = this._checkIsWritable(evt);
+                this._isMongos = this._checkIsMongos(evt);
+                const attr = {
+                    isWritable: this.isWritable(),
+                    isMongos: this.isMongos(),
+                    previousType: evt.previousDescription.type,
+                    newType: evt.newDescription.type,
+                };
+                log.info(mongoLogId(1001000021), this._logCtx(), 'Topology description changed', attr);
+                this._lastSeenTopology = evt.newDescription;
+                this.emit('topologyDescriptionChanged', evt);
+            });
+            const heartbeatStatusMap = new Map();
+            const isSignificantDurationChange = (before, after) => {
+                before = Math.max(before, 200);
+                after = Math.max(after, 200);
+                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,
+                    });
+                    log.write({
+                        s: 'D2',
+                        id: mongoLogId(1001000022),
+                        ctx: this._logCtx(),
+                        msg: 'Server heartbeat succeeded',
+                        attr: {
+                            connectionId: evt.connectionId,
+                            duration: evt.duration,
+                        },
+                    });
+                }
+                this.emit('serverHeartbeatSucceeded', evt);
+            });
+            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,
+                    });
+                    log.warn(mongoLogId(1001000023), this._logCtx(), 'Server heartbeat failed', {
+                        connectionId: evt.connectionId,
+                        duration: evt.duration,
+                        failure: evt.failure.message,
+                    });
+                }
+                this.emit('serverHeartbeatFailed', evt);
+            });
+            client.on('commandSucceeded', (evt) => {
+                const { address, connectionId, duration, commandName } = evt;
+                log.write({
+                    s: 'D2',
+                    id: mongoLogId(1001000029),
+                    ctx: this._logCtx(),
+                    msg: 'Driver command succeeded',
+                    attr: {
+                        address,
+                        serverConnectionId: connectionId,
+                        duration,
+                        commandName,
+                    },
+                });
+            });
+            client.on('commandFailed', (evt) => {
+                const { address, connectionId, duration, commandName, failure } = evt;
+                log.write({
+                    s: 'D1',
+                    id: mongoLogId(1001000030),
+                    ctx: this._logCtx(),
+                    msg: 'Driver command failed',
+                    attr: {
+                        address,
+                        serverConnectionId: connectionId,
+                        duration,
+                        commandName,
+                        failure: failure.message,
+                    },
+                });
+            });
+        }
+    }
+    get _initializedClient() {
+        if (!this._client) {
+            throw new Error('client not yet initialized');
+        }
+        return this._client;
+    }
+    get _defaultDb() {
+        return this._initializedClient.db();
+    }
+    async databaseStats(name) {
+        const logop = this._startLogOp(mongoLogId(1001000057), 'Running databaseStats', { db: name });
+        try {
+            const db = this._initializedClient.db(name);
+            const stats = await run_command_1.runCommand(db, { dbStats: 1 });
+            const { _id, ...normalized } = instance_detail_helper_1.adaptDatabaseInfo(stats);
+            return normalized;
+        }
+        catch (err) {
+            logop(err);
+            throw this._translateMessage(err);
+        }
+    }
+    _buildCollectionDetail(ns, data) {
+        return {
+            ...data.stats,
+            _id: ns,
+            name: this._collectionName(ns),
+            database: this._databaseName(ns),
+            indexes: data.indexes,
+        };
+    }
+    _buildCollectionStats(databaseName, collectionName, data) {
+        var _a;
+        return {
+            ns: databaseName + '.' + collectionName,
+            name: collectionName,
+            database: databaseName,
+            is_capped: data.capped,
+            max: data.max,
+            is_power_of_two: data.userFlags === 1,
+            index_sizes: data.indexSizes,
+            document_count: (_a = data.count) !== null && _a !== void 0 ? _a : 0,
+            document_size: data.size,
+            storage_size: data.storageSize,
+            index_count: data.nindexes,
+            index_size: data.totalIndexSize,
+            padding_factor: data.paddingFactor,
+            extent_count: data.numExtents,
+            extent_last_size: data.lastExtentSize,
+            flags_user: data.userFlags,
+            max_document_size: data.maxSize,
+            size: data.size,
+            index_details: data.indexDetails || {},
+            wired_tiger: data.wiredTiger || {},
+        };
+    }
+    _buildDatabaseDetail(name, db) {
+        return {
+            _id: name,
+            name: name,
+            stats: db.stats,
+            collections: db.collections,
+        };
+    }
+    _collection(ns) {
+        return this._initializedClient
+            .db(this._databaseName(ns))
+            .collection(this._collectionName(ns));
+    }
+    _collectionNames(databaseName, callback) {
+        this.listCollections(databaseName, {}, { nameOnly: true }).then((collections) => {
+            const names = collections === null || collections === void 0 ? void 0 : collections.map((c) => c.name);
+            callback(null, names);
+        }, (error) => {
+            callback(this._translateMessage(error));
+        });
+    }
+    _collectionName(ns) {
+        return parseNamespace(ns).collection;
+    }
+    _databaseName(ns) {
+        return parseNamespace(ns).database;
+    }
+    _checkIsWritable(evt) {
+        return [...evt.newDescription.servers.values()].some((server) => server.isWritable);
+    }
+    _checkIsMongos(evt) {
+        return evt.newDescription.type === 'Sharded';
+    }
+    _translateMessage(error) {
+        if (typeof error === 'string') {
+            error = { message: error };
+        }
+        else {
+            error.message = error.message || error.err || error.errmsg;
+        }
+        return error;
+    }
+    _cleanup() {
+        if (this._client) {
+            this._client.removeAllListeners();
+        }
+        this._client = undefined;
+        this._tunnel = undefined;
+        this._mongoClientConnectionOptions = undefined;
+        this._isWritable = false;
+        this._isMongos = false;
+        this._isConnecting = false;
+    }
+    _startLogOp(logId, op, attr = {}) {
+        return (error, result) => {
+            if (error) {
+                const { message } = this._translateMessage(error);
+                log.error(mongoLogId(1001000058), this._logCtx(), 'Failed to perform data service operation', {
+                    op,
+                    message,
+                    ...attr,
+                });
+            }
+            else {
+                if (result) {
+                    attr = { ...attr, result };
+                }
+                if (Object.keys(attr).length > 0) {
+                    log.info(logId, this._logCtx(), op, attr);
+                }
+                else {
+                    log.info(logId, this._logCtx(), op);
+                }
+            }
+        };
     }
 }
-module.exports = DataService;
+exports.default = DataService;
 //# sourceMappingURL=data-service.js.map