mongodb 6.2.0 → 6.3.0-dev.20240108.sha.7f3ce0b

package/lib/cmap/connection.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.hasSessionSupport = exports.CryptoConnection = exports.Connection = void 0;
+exports.CryptoConnection = exports.SizedMessageTransform = exports.Connection = exports.hasSessionSupport = void 0;
+const stream_1 = require("stream");
 const timers_1 = require("timers");
 const util_1 = require("util");
 const constants_1 = require("../constants");
@@ -10,84 +11,66 @@ const sessions_1 = require("../sessions");
 const utils_1 = require("../utils");
 const command_monitoring_events_1 = require("./command_monitoring_events");
 const commands_1 = require("./commands");
-const message_stream_1 = require("./message_stream");
 const stream_description_1 = require("./stream_description");
+const compression_1 = require("./wire_protocol/compression");
+const on_data_1 = require("./wire_protocol/on_data");
 const shared_1 = require("./wire_protocol/shared");
 /** @internal */
-const kStream = Symbol('stream');
-/** @internal */
-const kQueue = Symbol('queue');
-/** @internal */
-const kMessageStream = Symbol('messageStream');
-/** @internal */
-const kGeneration = Symbol('generation');
-/** @internal */
-const kLastUseTime = Symbol('lastUseTime');
-/** @internal */
-const kClusterTime = Symbol('clusterTime');
-/** @internal */
-const kDescription = Symbol('description');
-/** @internal */
-const kHello = Symbol('hello');
-/** @internal */
-const kAutoEncrypter = Symbol('autoEncrypter');
-/** @internal */
-const kDelayedTimeoutId = Symbol('delayedTimeoutId');
-const INVALID_QUEUE_SIZE = 'Connection internal queue contains more than 1 operation description';
+function hasSessionSupport(conn) {
+    const description = conn.description;
+    return description.logicalSessionTimeoutMinutes != null;
+}
+exports.hasSessionSupport = hasSessionSupport;
+function streamIdentifier(stream, options) {
+    if (options.proxyHost) {
+        // If proxy options are specified, the properties of `stream` itself
+        // will not accurately reflect what endpoint this is connected to.
+        return options.hostAddress.toString();
+    }
+    const { remoteAddress, remotePort } = stream;
+    if (typeof remoteAddress === 'string' && typeof remotePort === 'number') {
+        return utils_1.HostAddress.fromHostPort(remoteAddress, remotePort).toString();
+    }
+    return (0, utils_1.uuidV4)().toString('hex');
+}
 /** @internal */
 class Connection extends mongo_types_1.TypedEventEmitter {
     constructor(stream, options) {
         super();
-        this.commandAsync = (0, util_1.promisify)((ns, cmd, options, callback) => this.command(ns, cmd, options, callback));
+        this.delayedTimeoutId = null;
+        this.clusterTime = null;
         this.id = options.id;
         this.address = streamIdentifier(stream, options);
         this.socketTimeoutMS = options.socketTimeoutMS ?? 0;
         this.monitorCommands = options.monitorCommands;
         this.serverApi = options.serverApi;
-        this.closed = false;
-        this[kHello] = null;
-        this[kClusterTime] = null;
-        this[kDescription] = new stream_description_1.StreamDescription(this.address, options);
-        this[kGeneration] = options.generation;
-        this[kLastUseTime] = (0, utils_1.now)();
-        // setup parser stream and message handling
-        this[kQueue] = new Map();
-        this[kMessageStream] = new message_stream_1.MessageStream({
-            ...options,
-            maxBsonMessageSize: this.hello?.maxBsonMessageSize
-        });
-        this[kStream] = stream;
-        this[kDelayedTimeoutId] = null;
-        this[kMessageStream].on('message', message => this.onMessage(message));
-        this[kMessageStream].on('error', error => this.onError(error));
-        this[kStream].on('close', () => this.onClose());
-        this[kStream].on('timeout', () => this.onTimeout());
-        this[kStream].on('error', () => {
-            /* ignore errors, listen to `close` instead */
-        });
-        // hook the message stream up to the passed in stream
-        this[kStream].pipe(this[kMessageStream]);
-        this[kMessageStream].pipe(this[kStream]);
+        this.description = new stream_description_1.StreamDescription(this.address, options);
+        this.generation = options.generation;
+        this.lastUseTime = (0, utils_1.now)();
+        this.socket = stream;
+        this.controller = new AbortController();
+        this.messageStream = this.socket
+            .on('error', this.onError.bind(this))
+            .pipe(new SizedMessageTransform({ connection: this }))
+            .on('error', this.onError.bind(this));
+        this.socket.on('close', this.onClose.bind(this));
+        this.socket.on('timeout', this.onTimeout.bind(this));
+        const socketWrite = (0, util_1.promisify)(this.socket.write.bind(this.socket));
+        this.socketWrite = async (buffer) => {
+            return (0, utils_1.abortable)(socketWrite(buffer), { signal: this.controller.signal });
+        };
     }
-    get description() {
-        return this[kDescription];
+    /** Indicates that the connection (including underlying TCP socket) has been closed. */
+    get closed() {
+        return this.controller.signal.aborted;
     }
     get hello() {
-        return this[kHello];
+        return this.description.hello;
     }
     // the `connect` method stores the result of the handshake hello on the connection
     set hello(response) {
-        this[kDescription].receiveResponse(response);
-        this[kDescription] = Object.freeze(this[kDescription]);
-        // TODO: remove this, and only use the `StreamDescription` in the future
-        this[kHello] = response;
-    }
-    // Set the whether the message stream is for a monitoring connection.
-    set isMonitoringConnection(value) {
-        this[kMessageStream].isMonitoringConnection = value;
-    }
-    get isMonitoringConnection() {
-        return this[kMessageStream].isMonitoringConnection;
+        this.description.receiveResponse(response);
+        Object.freeze(this.description);
     }
     get serviceId() {
         return this.hello?.serviceId;
@@ -95,119 +78,38 @@ class Connection extends mongo_types_1.TypedEventEmitter {
     get loadBalanced() {
         return this.description.loadBalanced;
     }
-    get generation() {
-        return this[kGeneration] || 0;
-    }
-    set generation(generation) {
-        this[kGeneration] = generation;
-    }
     get idleTime() {
-        return (0, utils_1.calculateDurationInMs)(this[kLastUseTime]);
+        return (0, utils_1.calculateDurationInMs)(this.lastUseTime);
     }
-    get clusterTime() {
-        return this[kClusterTime];
+    get hasSessionSupport() {
+        return this.description.logicalSessionTimeoutMinutes != null;
     }
-    get stream() {
-        return this[kStream];
+    get supportsOpMsg() {
+        return (this.description != null &&
+            (0, utils_1.maxWireVersion)(this) >= 6 &&
+            !this.description.__nodejs_mock_server__);
     }
     markAvailable() {
-        this[kLastUseTime] = (0, utils_1.now)();
+        this.lastUseTime = (0, utils_1.now)();
     }
     onError(error) {
-        this.cleanup(true, error);
+        this.cleanup(error);
     }
     onClose() {
         const message = `connection ${this.id} to ${this.address} closed`;
-        this.cleanup(true, new error_1.MongoNetworkError(message));
+        this.cleanup(new error_1.MongoNetworkError(message));
     }
     onTimeout() {
-        this[kDelayedTimeoutId] = (0, timers_1.setTimeout)(() => {
+        this.delayedTimeoutId = (0, timers_1.setTimeout)(() => {
             const message = `connection ${this.id} to ${this.address} timed out`;
             const beforeHandshake = this.hello == null;
-            this.cleanup(true, new error_1.MongoNetworkTimeoutError(message, { beforeHandshake }));
+            this.cleanup(new error_1.MongoNetworkTimeoutError(message, { beforeHandshake }));
         }, 1).unref(); // No need for this timer to hold the event loop open
     }
-    onMessage(message) {
-        const delayedTimeoutId = this[kDelayedTimeoutId];
-        if (delayedTimeoutId != null) {
-            (0, timers_1.clearTimeout)(delayedTimeoutId);
-            this[kDelayedTimeoutId] = null;
-        }
-        const socketTimeoutMS = this[kStream].timeout ?? 0;
-        this[kStream].setTimeout(0);
-        // always emit the message, in case we are streaming
-        this.emit('message', message);
-        let operationDescription = this[kQueue].get(message.responseTo);
-        if (!operationDescription && this.isMonitoringConnection) {
-            // This is how we recover when the initial hello's requestId is not
-            // the responseTo when hello responses have been skipped:
-            // First check if the map is of invalid size
-            if (this[kQueue].size > 1) {
-                this.cleanup(true, new error_1.MongoRuntimeError(INVALID_QUEUE_SIZE));
-            }
-            else {
-                // Get the first orphaned operation description.
-                const entry = this[kQueue].entries().next();
-                if (entry.value != null) {
-                    const [requestId, orphaned] = entry.value;
-                    // If the orphaned operation description exists then set it.
-                    operationDescription = orphaned;
-                    // Remove the entry with the bad request id from the queue.
-                    this[kQueue].delete(requestId);
-                }
-            }
-        }
-        if (!operationDescription) {
-            return;
-        }
-        const callback = operationDescription.cb;
-        // SERVER-45775: For exhaust responses we should be able to use the same requestId to
-        // track response, however the server currently synthetically produces remote requests
-        // making the `responseTo` change on each response
-        this[kQueue].delete(message.responseTo);
-        if ('moreToCome' in message && message.moreToCome) {
-            // If the operation description check above does find an orphaned
-            // description and sets the operationDescription then this line will put one
-            // back in the queue with the correct requestId and will resolve not being able
-            // to find the next one via the responseTo of the next streaming hello.
-            this[kQueue].set(message.requestId, operationDescription);
-            this[kStream].setTimeout(socketTimeoutMS);
-        }
-        try {
-            // Pass in the entire description because it has BSON parsing options
-            message.parse(operationDescription);
-        }
-        catch (err) {
-            // If this error is generated by our own code, it will already have the correct class applied
-            // if it is not, then it is coming from a catastrophic data parse failure or the BSON library
-            // in either case, it should not be wrapped
-            callback(err);
-            return;
-        }
-        if (message.documents[0]) {
-            const document = message.documents[0];
-            const session = operationDescription.session;
-            if (session) {
-                (0, sessions_1.updateSessionFromResponse)(session, document);
-            }
-            if (document.$clusterTime) {
-                this[kClusterTime] = document.$clusterTime;
-                this.emit(Connection.CLUSTER_TIME_RECEIVED, document.$clusterTime);
-            }
-            if (document.writeConcernError) {
-                callback(new error_1.MongoWriteConcernError(document.writeConcernError, document), document);
-                return;
-            }
-            if (document.ok === 0 || document.$err || document.errmsg || document.code) {
-                callback(new error_1.MongoServerError(document));
-                return;
-            }
-        }
-        callback(undefined, message.documents[0]);
-    }
     destroy(options, callback) {
         if (this.closed) {
-            process.nextTick(() => callback?.());
+            if (typeof callback === 'function')
+                process.nextTick(callback);
             return;
         }
         if (typeof callback === 'function') {
@@ -219,7 +121,7 @@ class Connection extends mongo_types_1.TypedEventEmitter {
         this.removeAllListeners(Connection.PINNED);
         this.removeAllListeners(Connection.UNPINNED);
         const message = `connection ${this.id} to ${this.address} closed`;
-        this.cleanup(options.force, new error_1.MongoNetworkError(message));
+        this.cleanup(new error_1.MongoNetworkError(message));
     }
     /**
      * A method that cleans up the connection.  When `force` is true, this method
@@ -229,40 +131,17 @@ class Connection extends mongo_types_1.TypedEventEmitter {
      *
      * This method does nothing if the connection is already closed.
      */
-    cleanup(force, error) {
+    cleanup(error) {
         if (this.closed) {
             return;
         }
-        this.closed = true;
-        const completeCleanup = () => {
-            for (const op of this[kQueue].values()) {
-                op.cb(error);
-            }
-            this[kQueue].clear();
-            this.emit(Connection.CLOSE);
-        };
-        this[kStream].removeAllListeners();
-        this[kMessageStream].removeAllListeners();
-        this[kMessageStream].destroy();
-        if (force) {
-            this[kStream].destroy();
-            completeCleanup();
-            return;
-        }
-        if (!this[kStream].writableEnded) {
-            this[kStream].end(() => {
-                this[kStream].destroy();
-                completeCleanup();
-            });
-        }
-        else {
-            completeCleanup();
-        }
+        this.socket.destroy();
+        this.controller.abort(error);
+        this.emit(Connection.CLOSE);
     }
-    command(ns, command, options, callback) {
+    prepareCommand(db, command, options) {
         let cmd = { ...command };
         const readPreference = (0, shared_1.getReadPreference)(options);
-        const shouldUseOpMsg = supportsOpMsg(this);
         const session = options?.session;
         let clusterTime = this.clusterTime;
         if (this.serverApi) {
@@ -273,45 +152,179 @@ class Connection extends mongo_types_1.TypedEventEmitter {
             if (deprecationErrors != null)
                 cmd.apiDeprecationErrors = deprecationErrors;
         }
-        if (hasSessionSupport(this) && session) {
+        if (this.hasSessionSupport && session) {
             if (session.clusterTime &&
                 clusterTime &&
                 session.clusterTime.clusterTime.greaterThan(clusterTime.clusterTime)) {
                 clusterTime = session.clusterTime;
             }
-            const err = (0, sessions_1.applySession)(session, cmd, options);
-            if (err) {
-                return callback(err);
-            }
+            const sessionError = (0, sessions_1.applySession)(session, cmd, options);
+            if (sessionError)
+                throw sessionError;
         }
         else if (session?.explicit) {
-            return callback(new error_1.MongoCompatibilityError('Current topology does not support sessions'));
+            throw new error_1.MongoCompatibilityError('Current topology does not support sessions');
         }
         // if we have a known cluster time, gossip it
         if (clusterTime) {
             cmd.$clusterTime = clusterTime;
         }
-        if ((0, shared_1.isSharded)(this) && !shouldUseOpMsg && readPreference && readPreference.mode !== 'primary') {
+        if ((0, shared_1.isSharded)(this) &&
+            !this.supportsOpMsg &&
+            readPreference &&
+            readPreference.mode !== 'primary') {
             cmd = {
                 $query: cmd,
                 $readPreference: readPreference.toJSON()
             };
         }
-        const commandOptions = Object.assign({
+        const commandOptions = {
             numberToSkip: 0,
             numberToReturn: -1,
             checkKeys: false,
             // This value is not overridable
-            secondaryOk: readPreference.secondaryOk()
-        }, options);
-        const message = shouldUseOpMsg
-            ? new commands_1.Msg(ns.db, cmd, commandOptions)
-            : new commands_1.Query(ns.db, cmd, commandOptions);
+            secondaryOk: readPreference.secondaryOk(),
+            ...options,
+            readPreference // ensure we pass in ReadPreference instance
+        };
+        const message = this.supportsOpMsg
+            ? new commands_1.OpMsgRequest(db, cmd, commandOptions)
+            : new commands_1.OpQueryRequest(db, cmd, commandOptions);
+        return message;
+    }
+    async *sendWire(message, options) {
+        this.controller.signal.throwIfAborted();
+        if (typeof options.socketTimeoutMS === 'number') {
+            this.socket.setTimeout(options.socketTimeoutMS);
+        }
+        else if (this.socketTimeoutMS !== 0) {
+            this.socket.setTimeout(this.socketTimeoutMS);
+        }
         try {
-            write(this, message, commandOptions, callback);
+            await this.writeCommand(message, {
+                agreedCompressor: this.description.compressor ?? 'none',
+                zlibCompressionLevel: this.description.zlibCompressionLevel
+            });
+            if (options.noResponse) {
+                yield { ok: 1 };
+                return;
+            }
+            this.controller.signal.throwIfAborted();
+            for await (const response of this.readMany()) {
+                this.socket.setTimeout(0);
+                response.parse(options);
+                const [document] = response.documents;
+                if (!Buffer.isBuffer(document)) {
+                    const { session } = options;
+                    if (session) {
+                        (0, sessions_1.updateSessionFromResponse)(session, document);
+                    }
+                    if (document.$clusterTime) {
+                        this.clusterTime = document.$clusterTime;
+                        this.emit(Connection.CLUSTER_TIME_RECEIVED, document.$clusterTime);
+                    }
+                }
+                yield document;
+                this.controller.signal.throwIfAborted();
+                if (typeof options.socketTimeoutMS === 'number') {
+                    this.socket.setTimeout(options.socketTimeoutMS);
+                }
+                else if (this.socketTimeoutMS !== 0) {
+                    this.socket.setTimeout(this.socketTimeoutMS);
+                }
+            }
         }
-        catch (err) {
-            callback(err);
+        finally {
+            this.socket.setTimeout(0);
+        }
+    }
+    async *sendCommand(ns, command, options = {}) {
+        const message = this.prepareCommand(ns.db, command, options);
+        let started = 0;
+        if (this.monitorCommands) {
+            started = (0, utils_1.now)();
+            this.emit(Connection.COMMAND_STARTED, new command_monitoring_events_1.CommandStartedEvent(this, message, this.description.serverConnectionId));
+        }
+        let document;
+        try {
+            this.controller.signal.throwIfAborted();
+            for await (document of this.sendWire(message, options)) {
+                if (!Buffer.isBuffer(document) && document.writeConcernError) {
+                    throw new error_1.MongoWriteConcernError(document.writeConcernError, document);
+                }
+                if (!Buffer.isBuffer(document) &&
+                    (document.ok === 0 || document.$err || document.errmsg || document.code)) {
+                    throw new error_1.MongoServerError(document);
+                }
+                if (this.monitorCommands) {
+                    this.emit(Connection.COMMAND_SUCCEEDED, new command_monitoring_events_1.CommandSucceededEvent(this, message, options.noResponse ? undefined : document, started, this.description.serverConnectionId));
+                }
+                yield document;
+                this.controller.signal.throwIfAborted();
+            }
+        }
+        catch (error) {
+            if (this.monitorCommands) {
+                if (error.name === 'MongoWriteConcernError') {
+                    this.emit(Connection.COMMAND_SUCCEEDED, new command_monitoring_events_1.CommandSucceededEvent(this, message, options.noResponse ? undefined : document, started, this.description.serverConnectionId));
+                }
+                else {
+                    this.emit(Connection.COMMAND_FAILED, new command_monitoring_events_1.CommandFailedEvent(this, message, error, started, this.description.serverConnectionId));
+                }
+            }
+            throw error;
+        }
+    }
+    async command(ns, command, options = {}) {
+        this.controller.signal.throwIfAborted();
+        for await (const document of this.sendCommand(ns, command, options)) {
+            return document;
+        }
+        throw new error_1.MongoUnexpectedServerResponseError('Unable to get response from server');
+    }
+    exhaustCommand(ns, command, options, replyListener) {
+        const exhaustLoop = async () => {
+            this.controller.signal.throwIfAborted();
+            for await (const reply of this.sendCommand(ns, command, options)) {
+                replyListener(undefined, reply);
+                this.controller.signal.throwIfAborted();
+            }
+            throw new error_1.MongoUnexpectedServerResponseError('Server ended moreToCome unexpectedly');
+        };
+        exhaustLoop().catch(replyListener);
+    }
+    /**
+     * @internal
+     *
+     * Writes an OP_MSG or OP_QUERY request to the socket, optionally compressing the command. This method
+     * waits until the socket's buffer has emptied (the Nodejs socket `drain` event has fired).
+     */
+    async writeCommand(command, options) {
+        const finalCommand = options.agreedCompressor === 'none' || !commands_1.OpCompressedRequest.canCompress(command)
+            ? command
+            : new commands_1.OpCompressedRequest(command, {
+                agreedCompressor: options.agreedCompressor ?? 'none',
+                zlibCompressionLevel: options.zlibCompressionLevel ?? 0
+            });
+        const buffer = Buffer.concat(await finalCommand.toBin());
+        return this.socketWrite(buffer);
+    }
+    /**
+     * @internal
+     *
+     * Returns an async generator that yields full wire protocol messages from the underlying socket.  This function
+     * yields messages until `moreToCome` is false or not present in a response, or the caller cancels the request
+     * by calling `return` on the generator.
+     *
+     * Note that `for-await` loops call `return` automatically when the loop is exited.
+     */
+    async *readMany() {
+        for await (const message of (0, on_data_1.onData)(this.messageStream, { signal: this.controller.signal })) {
+            const response = await (0, compression_1.decompressResponse)(message);
+            yield response;
+            if (!response.moreToCome) {
+                return;
+            }
         }
     }
 }
@@ -326,32 +339,57 @@ Connection.CLUSTER_TIME_RECEIVED = constants_1.CLUSTER_TIME_RECEIVED;
 /** @event */
 Connection.CLOSE = constants_1.CLOSE;
 /** @event */
-Connection.MESSAGE = constants_1.MESSAGE;
-/** @event */
 Connection.PINNED = constants_1.PINNED;
 /** @event */
 Connection.UNPINNED = constants_1.UNPINNED;
 exports.Connection = Connection;
 /** @internal */
+class SizedMessageTransform extends stream_1.Transform {
+    constructor({ connection }) {
+        super({ objectMode: false });
+        this.bufferPool = new utils_1.BufferPool();
+        this.connection = connection;
+    }
+    _transform(chunk, encoding, callback) {
+        if (this.connection.delayedTimeoutId != null) {
+            (0, timers_1.clearTimeout)(this.connection.delayedTimeoutId);
+            this.connection.delayedTimeoutId = null;
+        }
+        this.bufferPool.append(chunk);
+        const sizeOfMessage = this.bufferPool.getInt32();
+        if (sizeOfMessage == null) {
+            return callback();
+        }
+        if (sizeOfMessage < 0) {
+            return callback(new error_1.MongoParseError(`Invalid message size: ${sizeOfMessage}, too small`));
+        }
+        if (sizeOfMessage > this.bufferPool.length) {
+            return callback();
+        }
+        const message = this.bufferPool.read(sizeOfMessage);
+        return callback(null, message);
+    }
+}
+exports.SizedMessageTransform = SizedMessageTransform;
+/** @internal */
 class CryptoConnection extends Connection {
     constructor(stream, options) {
         super(stream, options);
-        this[kAutoEncrypter] = options.autoEncrypter;
+        this.autoEncrypter = options.autoEncrypter;
     }
     /** @internal @override */
-    command(ns, cmd, options, callback) {
-        const autoEncrypter = this[kAutoEncrypter];
+    async command(ns, cmd, options) {
+        const { autoEncrypter } = this;
         if (!autoEncrypter) {
-            return callback(new error_1.MongoMissingDependencyError('No AutoEncrypter available for encryption'));
+            throw new error_1.MongoMissingDependencyError('No AutoEncrypter available for encryption');
         }
         const serverWireVersion = (0, utils_1.maxWireVersion)(this);
         if (serverWireVersion === 0) {
             // This means the initial handshake hasn't happened yet
-            return super.command(ns, cmd, options, callback);
+            return super.command(ns, cmd, options);
         }
         if (serverWireVersion < 8) {
-            callback(new error_1.MongoCompatibilityError('Auto-encryption requires a minimum MongoDB version of 4.2'));
-            return;
+            throw new error_1.MongoCompatibilityError('Auto-encryption requires a minimum MongoDB version of 4.2');
         }
         // Save sort or indexKeys based on the command being run
         // the encrypt API serializes our JS objects to BSON to pass to the native code layer
@@ -363,130 +401,20 @@ class CryptoConnection extends Connection {
         const indexKeys = cmd.createIndexes
             ? cmd.indexes.map((index) => index.key)
             : null;
-        autoEncrypter.encrypt(ns.toString(), cmd, options).then(encrypted => {
-            // Replace the saved values
-            if (sort != null && (cmd.find || cmd.findAndModify)) {
-                encrypted.sort = sort;
-            }
-            if (indexKeys != null && cmd.createIndexes) {
-                for (const [offset, index] of indexKeys.entries()) {
-                    // @ts-expect-error `encrypted` is a generic "command", but we've narrowed for only `createIndexes` commands here
-                    encrypted.indexes[offset].key = index;
-                }
-            }
-            super.command(ns, encrypted, options, (err, response) => {
-                if (err || response == null) {
-                    callback(err, response);
-                    return;
-                }
-                autoEncrypter.decrypt(response, options).then(res => callback(undefined, res), err => callback(err));
-            });
-        }, err => {
-            if (err) {
-                callback(err, null);
-            }
-        });
-    }
-}
-exports.CryptoConnection = CryptoConnection;
-/** @internal */
-function hasSessionSupport(conn) {
-    const description = conn.description;
-    return description.logicalSessionTimeoutMinutes != null;
-}
-exports.hasSessionSupport = hasSessionSupport;
-function supportsOpMsg(conn) {
-    const description = conn.description;
-    if (description == null) {
-        return false;
-    }
-    return (0, utils_1.maxWireVersion)(conn) >= 6 && !description.__nodejs_mock_server__;
-}
-function streamIdentifier(stream, options) {
-    if (options.proxyHost) {
-        // If proxy options are specified, the properties of `stream` itself
-        // will not accurately reflect what endpoint this is connected to.
-        return options.hostAddress.toString();
-    }
-    const { remoteAddress, remotePort } = stream;
-    if (typeof remoteAddress === 'string' && typeof remotePort === 'number') {
-        return utils_1.HostAddress.fromHostPort(remoteAddress, remotePort).toString();
-    }
-    return (0, utils_1.uuidV4)().toString('hex');
-}
-function write(conn, command, options, callback) {
-    options = options ?? {};
-    const operationDescription = {
-        requestId: command.requestId,
-        cb: callback,
-        session: options.session,
-        noResponse: typeof options.noResponse === 'boolean' ? options.noResponse : false,
-        documentsReturnedIn: options.documentsReturnedIn,
-        // for BSON parsing
-        useBigInt64: typeof options.useBigInt64 === 'boolean' ? options.useBigInt64 : false,
-        promoteLongs: typeof options.promoteLongs === 'boolean' ? options.promoteLongs : true,
-        promoteValues: typeof options.promoteValues === 'boolean' ? options.promoteValues : true,
-        promoteBuffers: typeof options.promoteBuffers === 'boolean' ? options.promoteBuffers : false,
-        bsonRegExp: typeof options.bsonRegExp === 'boolean' ? options.bsonRegExp : false,
-        enableUtf8Validation: typeof options.enableUtf8Validation === 'boolean' ? options.enableUtf8Validation : true,
-        raw: typeof options.raw === 'boolean' ? options.raw : false,
-        started: 0
-    };
-    if (conn[kDescription] && conn[kDescription].compressor) {
-        operationDescription.agreedCompressor = conn[kDescription].compressor;
-        if (conn[kDescription].zlibCompressionLevel) {
-            operationDescription.zlibCompressionLevel = conn[kDescription].zlibCompressionLevel;
+        const encrypted = await autoEncrypter.encrypt(ns.toString(), cmd, options);
+        // Replace the saved values
+        if (sort != null && (cmd.find || cmd.findAndModify)) {
+            encrypted.sort = sort;
         }
-    }
-    if (typeof options.socketTimeoutMS === 'number') {
-        conn[kStream].setTimeout(options.socketTimeoutMS);
-    }
-    else if (conn.socketTimeoutMS !== 0) {
-        conn[kStream].setTimeout(conn.socketTimeoutMS);
-    }
-    // if command monitoring is enabled we need to modify the callback here
-    if (conn.monitorCommands) {
-        conn.emit(Connection.COMMAND_STARTED, new command_monitoring_events_1.CommandStartedEvent(conn, command));
-        operationDescription.started = (0, utils_1.now)();
-        operationDescription.cb = (err, reply) => {
-            // Command monitoring spec states that if ok is 1, then we must always emit
-            // a command succeeded event, even if there's an error. Write concern errors
-            // will have an ok: 1 in their reply.
-            if (err && reply?.ok !== 1) {
-                conn.emit(Connection.COMMAND_FAILED, new command_monitoring_events_1.CommandFailedEvent(conn, command, err, operationDescription.started));
+        if (indexKeys != null && cmd.createIndexes) {
+            for (const [offset, index] of indexKeys.entries()) {
+                // @ts-expect-error `encrypted` is a generic "command", but we've narrowed for only `createIndexes` commands here
+                encrypted.indexes[offset].key = index;
             }
-            else {
-                if (reply && (reply.ok === 0 || reply.$err)) {
-                    conn.emit(Connection.COMMAND_FAILED, new command_monitoring_events_1.CommandFailedEvent(conn, command, reply, operationDescription.started));
-                }
-                else {
-                    conn.emit(Connection.COMMAND_SUCCEEDED, new command_monitoring_events_1.CommandSucceededEvent(conn, command, reply, operationDescription.started));
-                }
-            }
-            if (typeof callback === 'function') {
-                // Since we're passing through the reply with the write concern error now, we
-                // need it not to be provided to the original callback in this case so
-                // retryability does not get tricked into thinking the command actually
-                // succeeded.
-                callback(err, err instanceof error_1.MongoWriteConcernError ? undefined : reply);
-            }
-        };
-    }
-    if (!operationDescription.noResponse) {
-        conn[kQueue].set(operationDescription.requestId, operationDescription);
-    }
-    try {
-        conn[kMessageStream].writeCommand(command, operationDescription);
-    }
-    catch (e) {
-        if (!operationDescription.noResponse) {
-            conn[kQueue].delete(operationDescription.requestId);
-            operationDescription.cb(e);
-            return;
         }
-    }
-    if (operationDescription.noResponse) {
-        operationDescription.cb();
+        const response = await super.command(ns, encrypted, options);
+        return autoEncrypter.decrypt(response, options);
     }
 }
+exports.CryptoConnection = CryptoConnection;
 //# sourceMappingURL=connection.js.map