@nullix/zod-mongoose-studio 1.0.13 → 2.0.0

package/.output/server/node_modules/mongodb/lib/cmap/commands.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.OpCompressedRequest = exports.OpMsgResponse = exports.OpMsgRequest = exports.DocumentSequence = exports.OpReply = exports.OpQueryRequest = void 0;
-const BSON = require("../bson");
+const bson_1 = require("../bson");
 const error_1 = require("../error");
 const compression_1 = require("./wire_protocol/compression");
 const constants_1 = require("./wire_protocol/constants");
@@ -20,7 +20,7 @@ const CURSOR_NOT_FOUND = 1;
 const QUERY_FAILURE = 2;
 const SHARD_CONFIG_STALE = 4;
 const AWAIT_CAPABLE = 8;
-const encodeUTF8Into = BSON.BSON.onDemand.ByteUtils.encodeUTF8Into;
+const encodeUTF8Into = bson_1.ByteUtils.encodeUTF8Into;
 /** @internal */
 class OpQueryRequest {
     constructor(databaseName, query, options) {
@@ -111,9 +111,9 @@ class OpQueryRequest {
         if (this.batchSize !== this.numberToReturn)
             this.numberToReturn = this.batchSize;
         // Allocate write protocol header buffer
-        const header = Buffer.alloc(4 * 4 + // Header
+        const header = bson_1.ByteUtils.allocate(4 * 4 + // Header
             4 + // Flags
-            Buffer.byteLength(this.ns) +
+            bson_1.ByteUtils.utf8ByteLength(this.ns) +
             1 + // namespace
             4 + // numberToSkip
             4 // numberToReturn
@@ -121,7 +121,7 @@ class OpQueryRequest {
         // Add header to buffers
         buffers.push(header);
         // Serialize the query
-        const query = BSON.serialize(this.query, {
+        const query = bson_1.BSON.serialize(this.query, {
             checkKeys: this.checkKeys,
             serializeFunctions: this.serializeFunctions,
             ignoreUndefined: this.ignoreUndefined
@@ -130,7 +130,7 @@ class OpQueryRequest {
         buffers.push(query);
         if (this.returnFieldSelector && Object.keys(this.returnFieldSelector).length > 0) {
             // Serialize the projection document
-            projection = BSON.serialize(this.returnFieldSelector, {
+            projection = bson_1.BSON.serialize(this.returnFieldSelector, {
                 checkKeys: this.checkKeys,
                 serializeFunctions: this.serializeFunctions,
                 ignoreUndefined: this.ignoreUndefined
@@ -172,7 +172,7 @@ class OpQueryRequest {
         header[index] = flags & 0xff;
         index = index + 4;
         // Write collection name
-        index = index + header.write(this.ns, index, 'utf8') + 1;
+        index = index + encodeUTF8Into(header, this.ns, index) + 1;
         header[index - 1] = 0;
         // Write header information flags numberToSkip
         header[index + 3] = (this.numberToSkip >> 24) & 0xff;
@@ -234,10 +234,10 @@ class OpReply {
         // (See https://www.mongodb.com/docs/manual/reference/mongodb-wire-protocol/#wire-op-reply)
         this.index = 20;
         // Read the message body
-        this.responseFlags = this.data.readInt32LE(0);
-        this.cursorId = new BSON.Long(this.data.readInt32LE(4), this.data.readInt32LE(8));
-        this.startingFrom = this.data.readInt32LE(12);
-        this.numberReturned = this.data.readInt32LE(16);
+        this.responseFlags = (0, bson_1.readInt32LE)(this.data, 0);
+        this.cursorId = new bson_1.BSON.Long((0, bson_1.readInt32LE)(this.data, 4), (0, bson_1.readInt32LE)(this.data, 8));
+        this.startingFrom = (0, bson_1.readInt32LE)(this.data, 12);
+        this.numberReturned = (0, bson_1.readInt32LE)(this.data, 16);
         if (this.numberReturned < 0 || this.numberReturned > 2 ** 32 - 1) {
             throw new RangeError(`OP_REPLY numberReturned is an invalid array length ${this.numberReturned}`);
         }
@@ -279,7 +279,7 @@ class DocumentSequence {
         this.serializedDocumentsLength = 0;
         // Document sequences starts with type 1 at the first byte.
         // Field strings must always be UTF-8.
-        const buffer = Buffer.allocUnsafe(1 + 4 + this.field.length + 1);
+        const buffer = bson_1.ByteUtils.allocateUnsafe(1 + 4 + this.field.length + 1);
         buffer[0] = 1;
         // Third part is the field name at offset 5 with trailing null byte.
         encodeUTF8Into(buffer, `${this.field}\0`, 5);
@@ -287,7 +287,7 @@ class DocumentSequence {
         this.header = buffer;
         if (documents) {
             for (const doc of documents) {
-                this.push(doc, BSON.serialize(doc));
+                this.push(doc, bson_1.BSON.serialize(doc));
             }
         }
     }
@@ -305,7 +305,9 @@ class DocumentSequence {
         // Push the document raw bson.
         this.chunks.push(buffer);
         // Write the new length.
-        this.header?.writeInt32LE(4 + this.field.length + 1 + this.serializedDocumentsLength, 1);
+        if (this.header) {
+            bson_1.NumberUtils.setInt32LE(this.header, 1, 4 + this.field.length + 1 + this.serializedDocumentsLength);
+        }
         return this.serializedDocumentsLength + this.header.length;
     }
     /**
@@ -313,7 +315,7 @@ class DocumentSequence {
      * @returns The section bytes.
      */
     toBin() {
-        return Buffer.concat(this.chunks);
+        return bson_1.ByteUtils.concat(this.chunks);
     }
 }
 exports.DocumentSequence = DocumentSequence;
@@ -356,18 +358,20 @@ class OpMsgRequest {
         if (this.exhaustAllowed) {
             flags |= OPTS_EXHAUST_ALLOWED;
         }
-        const header = Buffer.alloc(4 * 4 + // Header
+        const header = bson_1.ByteUtils.allocate(4 * 4 + // Header
             4 // Flags
         );
         buffers.push(header);
         let totalLength = header.length;
         const command = this.command;
         totalLength += this.makeSections(buffers, command);
-        header.writeInt32LE(totalLength, 0); // messageLength
-        header.writeInt32LE(this.requestId, 4); // requestID
-        header.writeInt32LE(0, 8); // responseTo
-        header.writeInt32LE(constants_1.OP_MSG, 12); // opCode
-        header.writeUInt32LE(flags, 16); // flags
+        bson_1.NumberUtils.setInt32LE(header, 0, totalLength); // messageLength
+        bson_1.NumberUtils.setInt32LE(header, 4, this.requestId); // requestID
+        bson_1.NumberUtils.setInt32LE(header, 8, 0); // responseTo
+        bson_1.NumberUtils.setInt32LE(header, 12, constants_1.OP_MSG); // opCode
+        // The OP_MSG spec calls out that flags is uint32:
+        // https://github.com/mongodb/specifications/blob/master/source/message/OP_MSG.md#op_msg-1
+        (0, bson_1.setUint32LE)(header, 16, flags); // flags
         return buffers;
     }
     /**
@@ -375,7 +379,7 @@ class OpMsgRequest {
      */
     makeSections(buffers, document) {
         const sequencesBuffer = this.extractDocumentSequences(document);
-        const payloadTypeBuffer = Buffer.allocUnsafe(1);
+        const payloadTypeBuffer = bson_1.ByteUtils.allocateUnsafe(1);
         payloadTypeBuffer[0] = 0;
         const documentBuffer = this.serializeBson(document);
         // First section, type 0
@@ -407,14 +411,14 @@ class OpMsgRequest {
             }
         }
         if (chunks.length > 0) {
-            return Buffer.concat(chunks);
+            return bson_1.ByteUtils.concat(chunks);
         }
         // If we have no document sequences we return an empty buffer for nothing to add
         // to the payload.
-        return Buffer.alloc(0);
+        return bson_1.ByteUtils.allocate(0);
     }
     serializeBson(document) {
-        return BSON.serialize(document, {
+        return bson_1.BSON.serialize(document, {
             checkKeys: this.checkKeys,
             serializeFunctions: this.serializeFunctions,
             ignoreUndefined: this.ignoreUndefined
@@ -448,7 +452,7 @@ class OpMsgResponse {
         this.opCode = msgHeader.opCode;
         this.fromCompressed = msgHeader.fromCompressed;
         // Read response flags
-        this.responseFlags = msgBody.readInt32LE(0);
+        this.responseFlags = (0, bson_1.readInt32LE)(msgBody, 0);
         this.checksumPresent = (this.responseFlags & OPTS_CHECKSUM_PRESENT) !== 0;
         this.moreToCome = (this.responseFlags & OPTS_MORE_TO_COME) !== 0;
         this.exhaustAllowed = (this.responseFlags & OPTS_EXHAUST_ALLOWED) !== 0;
@@ -469,9 +473,12 @@ class OpMsgResponse {
             return this.sections[0];
         this.index = 4;
         while (this.index < this.data.length) {
-            const payloadType = this.data.readUInt8(this.index++);
+            const payloadType = this.data[this.index++];
             if (payloadType === 0) {
-                const bsonSize = this.data.readUInt32LE(this.index);
+                // BSON spec specifies that this is a 32-bit signed integer: https://bsonspec.org/spec.html#:~:text=%3A%3A%3D-,int32,-e_list%20unsigned_byte(0
+                // While allowing negative sizes seems odd, in practice we never expect a negative size. Also, the server's 16mb limit for BSON documents leaves plenty
+                // of room in an int32 to store a document of the max BSON size that the server supports
+                const bsonSize = (0, bson_1.readInt32LE)(this.data, this.index);
                 const bin = this.data.subarray(this.index, this.index + bsonSize);
                 this.sections.push(bin);
                 this.index += bsonSize;
@@ -510,24 +517,24 @@ class OpCompressedRequest {
         return !compression_1.uncompressibleCommands.has(commandName);
     }
     async toBin() {
-        const concatenatedOriginalCommandBuffer = Buffer.concat(this.command.toBin());
+        const concatenatedOriginalCommandBuffer = bson_1.ByteUtils.concat(this.command.toBin());
         // otherwise, compress the message
         const messageToBeCompressed = concatenatedOriginalCommandBuffer.slice(MESSAGE_HEADER_SIZE);
         // Extract information needed for OP_COMPRESSED from the uncompressed message
-        const originalCommandOpCode = concatenatedOriginalCommandBuffer.readInt32LE(12);
+        const originalCommandOpCode = (0, bson_1.readInt32LE)(concatenatedOriginalCommandBuffer, 12);
         // Compress the message body
         const compressedMessage = await (0, compression_1.compress)(this.options, messageToBeCompressed);
         // Create the msgHeader of OP_COMPRESSED
-        const msgHeader = Buffer.alloc(MESSAGE_HEADER_SIZE);
-        msgHeader.writeInt32LE(MESSAGE_HEADER_SIZE + COMPRESSION_DETAILS_SIZE + compressedMessage.length, 0); // messageLength
-        msgHeader.writeInt32LE(this.command.requestId, 4); // requestID
-        msgHeader.writeInt32LE(0, 8); // responseTo (zero)
-        msgHeader.writeInt32LE(constants_1.OP_COMPRESSED, 12); // opCode
+        const msgHeader = bson_1.ByteUtils.allocate(MESSAGE_HEADER_SIZE);
+        bson_1.NumberUtils.setInt32LE(msgHeader, 0, MESSAGE_HEADER_SIZE + COMPRESSION_DETAILS_SIZE + compressedMessage.length); // messageLength
+        bson_1.NumberUtils.setInt32LE(msgHeader, 4, this.command.requestId); // requestID
+        bson_1.NumberUtils.setInt32LE(msgHeader, 8, 0); // responseTo (zero)
+        bson_1.NumberUtils.setInt32LE(msgHeader, 12, constants_1.OP_COMPRESSED); // opCode
         // Create the compression details of OP_COMPRESSED
-        const compressionDetails = Buffer.alloc(COMPRESSION_DETAILS_SIZE);
-        compressionDetails.writeInt32LE(originalCommandOpCode, 0); // originalOpcode
-        compressionDetails.writeInt32LE(messageToBeCompressed.length, 4); // Size of the uncompressed compressedMessage, excluding the MsgHeader
-        compressionDetails.writeUInt8(compression_1.Compressor[this.options.agreedCompressor], 8); // compressorID
+        const compressionDetails = bson_1.ByteUtils.allocate(COMPRESSION_DETAILS_SIZE);
+        bson_1.NumberUtils.setInt32LE(compressionDetails, 0, originalCommandOpCode); // originalOpcode
+        bson_1.NumberUtils.setInt32LE(compressionDetails, 4, messageToBeCompressed.length); // Size of the uncompressed compressedMessage, excluding the MsgHeader
+        compressionDetails[8] = compression_1.Compressor[this.options.agreedCompressor]; // compressorID
         return [msgHeader, compressionDetails, compressedMessage];
     }
 }

package/.output/server/node_modules/mongodb/lib/cmap/connect.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.LEGAL_TCP_SOCKET_OPTIONS = exports.LEGAL_TLS_SOCKET_OPTIONS = void 0;
+exports.LEGAL_TCP_SOCKET_OPTIONS = exports.LEGAL_TLS_SOCKET_OPTIONS = exports.DEFAULT_KEEP_ALIVE_INITIAL_DELAY_MS = void 0;
 exports.connect = connect;
 exports.makeConnection = makeConnection;
 exports.performInitialHandshake = performInitialHandshake;
@@ -16,6 +16,10 @@ const auth_provider_1 = require("./auth/auth_provider");
 const providers_1 = require("./auth/providers");
 const connection_1 = require("./connection");
 const constants_2 = require("./wire_protocol/constants");
+function applyBackpressureLabels(error) {
+    error.addErrorLabel(error_1.MongoErrorLabel.SystemOverloadedError);
+    error.addErrorLabel(error_1.MongoErrorLabel.RetryableError);
+}
 async function connect(options) {
     let connection = null;
     try {
@@ -61,6 +65,8 @@ async function performInitialHandshake(conn, options) {
     }
     const authContext = new auth_provider_1.AuthContext(conn, credentials, options);
     conn.authContext = authContext;
+    // If we encounter an error preparing the handshake document, do NOT apply backpressure labels.  Errors
+    // encountered building the handshake document are all client-side, and do not indicate an overloaded server.
     const handshakeDoc = await prepareHandshakeDocument(authContext);
     // @ts-expect-error: TODO(NODE-5141): The options need to be filtered properly, Connection options differ from Command options
     const handshakeOptions = { ...options, raw: false };
@@ -104,6 +110,7 @@ async function performInitialHandshake(conn, options) {
             await provider.auth(authContext);
         }
         catch (error) {
+            // NOTE: If we encounter an error authenticating a connection, do NOT apply backpressure labels.
             if (error instanceof error_1.MongoError) {
                 error.addErrorLabel(error_1.MongoErrorLabel.HandshakeError);
                 if ((0, error_1.needsRetryableWriteLabel)(error, response.maxWireVersion, conn.description.type)) {
@@ -125,6 +132,10 @@ async function performInitialHandshake(conn, options) {
             if (error instanceof error_1.MongoError) {
                 error.addErrorLabel(error_1.MongoErrorLabel.HandshakeError);
             }
+            // If we encounter a network error executing the initial handshake, apply backpressure labels.
+            if (error instanceof error_1.MongoNetworkError) {
+                applyBackpressureLabels(error);
+            }
             throw error;
         }
     }
@@ -138,9 +149,10 @@ async function prepareHandshakeDocument(authContext) {
     const options = authContext.options;
     const compressors = options.compressors ? options.compressors : [];
     const { serverApi } = authContext.connection;
-    const clientMetadata = await options.extendedMetadata;
+    const clientMetadata = await options.metadata;
     const handshakeDoc = {
         [serverApi?.version || options.loadBalanced === true ? 'hello' : constants_1.LEGACY_HELLO_COMMAND]: 1,
+        backpressure: true,
         helloOk: true,
         client: clientMetadata,
         compression: compressors
@@ -167,6 +179,14 @@ async function prepareHandshakeDocument(authContext) {
     }
     return handshakeDoc;
 }
+/**
+ * @internal
+ * Default TCP keepAlive initial delay in milliseconds.
+ * Set to half the Azure load balancer idle timeout (240s) to ensure
+ * probes fire well before cloud LBs (Azure, AWS PrivateLink/NLB)
+ * drop idle connections.
+ */
+exports.DEFAULT_KEEP_ALIVE_INITIAL_DELAY_MS = 120_000;
 /** @public */
 exports.LEGAL_TLS_SOCKET_OPTIONS = [
     'allowPartialTrustChain',
@@ -208,7 +228,7 @@ function parseConnectOptions(options) {
             result[name] = options[name];
         }
     }
-    result.keepAliveInitialDelay ??= 120000;
+    result.keepAliveInitialDelay ??= exports.DEFAULT_KEEP_ALIVE_INITIAL_DELAY_MS;
     result.keepAlive = true;
     result.noDelay = options.noDelay ?? true;
     if (typeof hostAddress.socketPath === 'string') {
@@ -248,6 +268,8 @@ async function makeSocket(options) {
     const useTLS = options.tls ?? false;
     const connectTimeoutMS = options.connectTimeoutMS ?? 30000;
     const existingSocket = options.existingSocket;
+    const keepAliveInitialDelay = options.keepAliveInitialDelay ?? exports.DEFAULT_KEEP_ALIVE_INITIAL_DELAY_MS;
+    const noDelay = options.noDelay ?? true;
     let socket;
     if (options.proxyHost != null) {
         // Currently, only Socks5 is supported.
@@ -272,6 +294,12 @@ async function makeSocket(options) {
     else {
         socket = net.createConnection(parseConnectOptions(options));
     }
+    // Explicit setKeepAlive/setNoDelay are required because tls.connect() silently
+    // ignores these constructor options due to a Node.js bug.
+    // See: https://github.com/nodejs/node/issues/62003
+    // TODO(NODE-7474): remove this fix once the underlying Node.js issue is resolved.
+    socket.setKeepAlive(true, keepAliveInitialDelay);
+    socket.setNoDelay(noDelay);
     socket.setTimeout(connectTimeoutMS);
     let cancellationHandler = null;
     const { promise: connectedSocket, resolve, reject } = (0, utils_1.promiseWithResolvers)();
@@ -298,6 +326,10 @@ async function makeSocket(options) {
         return socket;
     }
     catch (error) {
+        // If we encounter an error while establishing a socket, apply the backpressure labels to it.  We cannot
+        // differentiate between DNS, TLS errors and network errors without refactoring our connection establishment to
+        // handle all three steps separately.
+        applyBackpressureLabels(error);
         socket.destroy();
         throw error;
     }

package/.output/server/node_modules/mongodb/lib/cmap/connection.js

@@ -36,10 +36,24 @@ function streamIdentifier(stream, options) {
     if (typeof remoteAddress === 'string' && typeof remotePort === 'number') {
         return utils_1.HostAddress.fromHostPort(remoteAddress, remotePort).toString();
     }
-    return (0, utils_1.uuidV4)().toString('hex');
+    return bson_1.ByteUtils.toHex((0, utils_1.uuidV4)());
 }
 /** @internal */
 class Connection extends mongo_types_1.TypedEventEmitter {
+    /** @event */
+    static { this.COMMAND_STARTED = constants_1.COMMAND_STARTED; }
+    /** @event */
+    static { this.COMMAND_SUCCEEDED = constants_1.COMMAND_SUCCEEDED; }
+    /** @event */
+    static { this.COMMAND_FAILED = constants_1.COMMAND_FAILED; }
+    /** @event */
+    static { this.CLUSTER_TIME_RECEIVED = constants_1.CLUSTER_TIME_RECEIVED; }
+    /** @event */
+    static { this.CLOSE = constants_1.CLOSE; }
+    /** @event */
+    static { this.PINNED = constants_1.PINNED; }
+    /** @event */
+    static { this.UNPINNED = constants_1.UNPINNED; }
     constructor(stream, options) {
         super();
         this.lastHelloMS = -1;
@@ -61,7 +75,7 @@ class Connection extends mongo_types_1.TypedEventEmitter {
         this.established = false;
         this.description = new stream_description_1.StreamDescription(this.address, options);
         this.generation = options.generation;
-        this.lastUseTime = (0, utils_1.now)();
+        this.lastUseTime = (0, utils_1.processTimeMS)();
         this.messageStream = this.socket
             .on('error', this.onSocketError.bind(this))
             .pipe(new SizedMessageTransform({ connection: this }))
@@ -104,7 +118,7 @@ class Connection extends mongo_types_1.TypedEventEmitter {
             false);
     }
     markAvailable() {
-        this.lastUseTime = (0, utils_1.now)();
+        this.lastUseTime = (0, utils_1.processTimeMS)();
     }
     onSocketError(cause) {
         this.onError(new error_1.MongoNetworkError(cause.message, { cause }));
@@ -242,7 +256,7 @@ class Connection extends mongo_types_1.TypedEventEmitter {
                 timeoutContext: options.timeoutContext,
                 signal: options.signal
             });
-            if (options.noResponse || message.moreToCome) {
+            if (message.moreToCome) {
                 yield responses_1.MongoDBResponse.empty;
                 return;
             }
@@ -270,7 +284,7 @@ class Connection extends mongo_types_1.TypedEventEmitter {
         const message = this.prepareCommand(ns.db, command, options);
         let started = 0;
         if (this.shouldEmitAndLogCommand) {
-            started = (0, utils_1.now)();
+            started = (0, utils_1.processTimeMS)();
             this.emitAndLogCommand(this.monitorCommands, Connection.COMMAND_STARTED, message.databaseName, this.established, new command_monitoring_events_1.CommandStartedEvent(this, message, this.description.serverConnectionId));
         }
         // If `documentsReturnedIn` not set or raw is not enabled, use input bson options
@@ -306,11 +320,7 @@ class Connection extends mongo_types_1.TypedEventEmitter {
                     throw new error_1.MongoServerError((object ??= document.toObject(bsonOptions)));
                 }
                 if (this.shouldEmitAndLogCommand) {
-                    this.emitAndLogCommand(this.monitorCommands, Connection.COMMAND_SUCCEEDED, message.databaseName, this.established, new command_monitoring_events_1.CommandSucceededEvent(this, message, options.noResponse
-                        ? undefined
-                        : message.moreToCome
-                            ? { ok: 1 }
-                            : (object ??= document.toObject(bsonOptions)), started, this.description.serverConnectionId));
+                    this.emitAndLogCommand(this.monitorCommands, Connection.COMMAND_SUCCEEDED, message.databaseName, this.established, new command_monitoring_events_1.CommandSucceededEvent(this, message, message.moreToCome ? { ok: 1 } : (object ??= document.toObject(bsonOptions)), started, this.description.serverConnectionId));
                 }
                 if (responseType == null) {
                     yield (object ??= document.toObject(bsonOptions));
@@ -322,6 +332,9 @@ class Connection extends mongo_types_1.TypedEventEmitter {
             }
         }
         catch (error) {
+            if (options.session != null && !(error instanceof error_1.MongoServerError)) {
+                (0, sessions_1.updateSessionFromResponse)(options.session, responses_1.MongoDBResponse.empty);
+            }
             if (this.shouldEmitAndLogCommand) {
                 this.emitAndLogCommand(this.monitorCommands, Connection.COMMAND_FAILED, message.databaseName, this.established, new command_monitoring_events_1.CommandFailedEvent(this, message, error, started, this.description.serverConnectionId));
             }
@@ -382,15 +395,24 @@ class Connection extends mongo_types_1.TypedEventEmitter {
                 agreedCompressor: options.agreedCompressor ?? 'none',
                 zlibCompressionLevel: options.zlibCompressionLevel ?? 0
             });
-        const buffer = Buffer.concat(await finalCommand.toBin());
+        const buffer = bson_1.ByteUtils.concat(await finalCommand.toBin());
         if (options.timeoutContext?.csotEnabled()) {
             if (options.timeoutContext.minRoundTripTime != null &&
                 options.timeoutContext.remainingTimeMS < options.timeoutContext.minRoundTripTime) {
                 throw new error_1.MongoOperationTimeoutError('Server roundtrip time is greater than the time remaining');
             }
         }
-        if (this.socket.write(buffer))
-            return;
+        try {
+            if (this.socket.write(buffer))
+                return;
+        }
+        catch (writeError) {
+            const networkError = new error_1.MongoNetworkError('unexpected error writing to socket', {
+                cause: writeError
+            });
+            this.onError(networkError);
+            throw networkError;
+        }
         const drainEvent = (0, utils_1.once)(this.socket, 'drain', options);
         const timeout = options?.timeoutContext?.timeoutForSocketWrite;
         const drained = timeout ? Promise.race([drainEvent, timeout]) : drainEvent;
@@ -452,20 +474,6 @@ class Connection extends mongo_types_1.TypedEventEmitter {
     }
 }
 exports.Connection = Connection;
-/** @event */
-Connection.COMMAND_STARTED = constants_1.COMMAND_STARTED;
-/** @event */
-Connection.COMMAND_SUCCEEDED = constants_1.COMMAND_SUCCEEDED;
-/** @event */
-Connection.COMMAND_FAILED = constants_1.COMMAND_FAILED;
-/** @event */
-Connection.CLUSTER_TIME_RECEIVED = constants_1.CLUSTER_TIME_RECEIVED;
-/** @event */
-Connection.CLOSE = constants_1.CLOSE;
-/** @event */
-Connection.PINNED = constants_1.PINNED;
-/** @event */
-Connection.UNPINNED = constants_1.UNPINNED;
 /** @internal */
 class SizedMessageTransform extends stream_1.Transform {
     constructor({ connection }) {
@@ -516,11 +524,7 @@ class CryptoConnection extends Connection {
     async command(ns, cmd, options, responseType) {
         const { autoEncrypter } = this;
         if (!autoEncrypter) {
-            // TODO(NODE-6065): throw a MongoRuntimeError in Node V7
-            // @ts-expect-error No cause provided because there is no underlying error.
-            throw new error_1.MongoMissingDependencyError('No AutoEncrypter available for encryption', {
-                dependencyName: 'n/a'
-            });
+            throw new error_1.MongoRuntimeError('No AutoEncrypter available for encryption');
         }
         const serverWireVersion = (0, utils_1.maxWireVersion)(this);
         if (serverWireVersion === 0) {