mongodb 6.5.0 → 6.6.0-dev.20240504.sha.2609953

package/src/cmap/connection.ts

@@ -38,6 +38,7 @@ import {
   type MongoDBNamespace,
   now,
   once,
+  squashError,
   uuidV4
 } from '../utils';
 import type { WriteConcern } from '../write_concern';
@@ -53,7 +54,7 @@ import {
   OpMsgRequest,
   type OpMsgResponse,
   OpQueryRequest,
-  type OpQueryResponse,
+  type OpReply,
   type WriteProtocolMessageType
 } from './commands';
 import type { Stream } from './connect';
@@ -61,6 +62,11 @@ import type { ClientMetadata } from './handshake/client_metadata';
 import { StreamDescription, type StreamDescriptionOptions } from './stream_description';
 import { type CompressorName, decompressResponse } from './wire_protocol/compression';
 import { onData } from './wire_protocol/on_data';
+import {
+  isErrorResponse,
+  MongoDBResponse,
+  type MongoDBResponseConstructor
+} from './wire_protocol/responses';
 import { getReadPreference, isSharded } from './wire_protocol/shared';
 
 /** @internal */
@@ -324,7 +330,8 @@ export class Connection extends TypedEventEmitter<ConnectionEvents> {
 
     this.socket.destroy();
     this.error = error;
-    this.dataEvents?.throw(error).then(undefined, () => null); // squash unhandled rejection
+    // eslint-disable-next-line github/no-then
+    this.dataEvents?.throw(error).then(undefined, squashError);
     this.closed = true;
     this.emit(Connection.CLOSE);
   }
@@ -410,7 +417,11 @@ export class Connection extends TypedEventEmitter<ConnectionEvents> {
     return message;
   }
 
-  private async *sendWire(message: WriteProtocolMessageType, options: CommandOptions) {
+  private async *sendWire(
+    message: WriteProtocolMessageType,
+    options: CommandOptions,
+    responseType?: MongoDBResponseConstructor
+  ): AsyncGenerator<MongoDBResponse> {
     this.throwIfAborted();
 
     if (typeof options.socketTimeoutMS === 'number') {
@@ -426,7 +437,7 @@ export class Connection extends TypedEventEmitter<ConnectionEvents> {
       });
 
       if (options.noResponse) {
-        yield { ok: 1 };
+        yield MongoDBResponse.empty;
         return;
       }
 
@@ -434,21 +445,14 @@ export class Connection extends TypedEventEmitter<ConnectionEvents> {
 
       for await (const response of this.readMany()) {
         this.socket.setTimeout(0);
-        response.parse(options);
+        const bson = response.parse();
 
-        const [document] = response.documents;
-
-        if (!Buffer.isBuffer(document)) {
-          const { session } = options;
-          if (session) {
-            updateSessionFromResponse(session, document);
-          }
-
-          if (document.$clusterTime) {
-            this.clusterTime = document.$clusterTime;
-            this.emit(Connection.CLUSTER_TIME_RECEIVED, document.$clusterTime);
-          }
-        }
+        const document =
+          responseType == null
+            ? new MongoDBResponse(bson)
+            : isErrorResponse(bson)
+            ? new MongoDBResponse(bson)
+            : new responseType(bson);
 
         yield document;
         this.throwIfAborted();
@@ -467,7 +471,8 @@ export class Connection extends TypedEventEmitter<ConnectionEvents> {
   private async *sendCommand(
     ns: MongoDBNamespace,
     command: Document,
-    options: CommandOptions = {}
+    options: CommandOptions,
+    responseType?: MongoDBResponseConstructor
   ) {
     const message = this.prepareCommand(ns.db, command, options);
 
@@ -483,19 +488,41 @@ export class Connection extends TypedEventEmitter<ConnectionEvents> {
       );
     }
 
-    let document;
+    // If `documentsReturnedIn` not set or raw is not enabled, use input bson options
+    // Otherwise, support raw flag. Raw only works for cursors that hardcode firstBatch/nextBatch fields
+    const bsonOptions =
+      options.documentsReturnedIn == null || !options.raw
+        ? options
+        : {
+            ...options,
+            raw: false,
+            fieldsAsRaw: { [options.documentsReturnedIn]: true }
+          };
+
+    /** MongoDBResponse instance or subclass */
+    let document: MongoDBResponse | undefined = undefined;
+    /** Cached result of a toObject call */
+    let object: Document | undefined = undefined;
     try {
       this.throwIfAborted();
-      for await (document of this.sendWire(message, options)) {
-        if (!Buffer.isBuffer(document) && document.writeConcernError) {
-          throw new MongoWriteConcernError(document.writeConcernError, document);
+      for await (document of this.sendWire(message, options, responseType)) {
+        object = undefined;
+        if (options.session != null) {
+          updateSessionFromResponse(options.session, document);
+        }
+
+        if (document.$clusterTime) {
+          this.clusterTime = document.$clusterTime;
+          this.emit(Connection.CLUSTER_TIME_RECEIVED, document.$clusterTime);
+        }
+
+        if (document.has('writeConcernError')) {
+          object ??= document.toObject(bsonOptions);
+          throw new MongoWriteConcernError(object.writeConcernError, object);
         }
 
-        if (
-          !Buffer.isBuffer(document) &&
-          (document.ok === 0 || document.$err || document.errmsg || document.code)
-        ) {
-          throw new MongoServerError(document);
+        if (document.isError) {
+          throw new MongoServerError((object ??= document.toObject(bsonOptions)));
         }
 
         if (this.shouldEmitAndLogCommand) {
@@ -507,14 +534,19 @@ export class Connection extends TypedEventEmitter<ConnectionEvents> {
             new CommandSucceededEvent(
               this,
               message,
-              options.noResponse ? undefined : document,
+              options.noResponse ? undefined : (object ??= document.toObject(bsonOptions)),
               started,
               this.description.serverConnectionId
             )
           );
         }
 
-        yield document;
+        if (responseType == null) {
+          yield (object ??= document.toObject(bsonOptions));
+        } else {
+          yield document;
+        }
+
         this.throwIfAborted();
       }
     } catch (error) {
@@ -528,7 +560,7 @@ export class Connection extends TypedEventEmitter<ConnectionEvents> {
             new CommandSucceededEvent(
               this,
               message,
-              options.noResponse ? undefined : document,
+              options.noResponse ? undefined : (object ??= document?.toObject(bsonOptions)),
               started,
               this.description.serverConnectionId
             )
@@ -553,13 +585,27 @@ export class Connection extends TypedEventEmitter<ConnectionEvents> {
     }
   }
 
+  public async command<T extends MongoDBResponseConstructor>(
+    ns: MongoDBNamespace,
+    command: Document,
+    options: CommandOptions | undefined,
+    responseType: T | undefined
+  ): Promise<typeof responseType extends undefined ? Document : InstanceType<T>>;
+
+  public async command(
+    ns: MongoDBNamespace,
+    command: Document,
+    options?: CommandOptions
+  ): Promise<Document>;
+
   public async command(
     ns: MongoDBNamespace,
     command: Document,
-    options: CommandOptions = {}
+    options: CommandOptions = {},
+    responseType?: MongoDBResponseConstructor
   ): Promise<Document> {
     this.throwIfAborted();
-    for await (const document of this.sendCommand(ns, command, options)) {
+    for await (const document of this.sendCommand(ns, command, options, responseType)) {
       return document;
     }
     throw new MongoUnexpectedServerResponseError('Unable to get response from server');
@@ -579,7 +625,8 @@ export class Connection extends TypedEventEmitter<ConnectionEvents> {
       }
       throw new MongoUnexpectedServerResponseError('Server ended moreToCome unexpectedly');
     };
-    exhaustLoop().catch(replyListener);
+    // eslint-disable-next-line github/no-then
+    exhaustLoop().then(undefined, replyListener);
   }
 
   private throwIfAborted() {
@@ -607,7 +654,7 @@ export class Connection extends TypedEventEmitter<ConnectionEvents> {
     const buffer = Buffer.concat(await finalCommand.toBin());
 
     if (this.socket.write(buffer)) return;
-    return once(this.socket, 'drain');
+    return await once(this.socket, 'drain');
   }
 
   /**
@@ -619,7 +666,7 @@ export class Connection extends TypedEventEmitter<ConnectionEvents> {
    *
    * Note that `for-await` loops call `return` automatically when the loop is exited.
    */
-  private async *readMany(): AsyncGenerator<OpMsgResponse | OpQueryResponse> {
+  private async *readMany(): AsyncGenerator<OpMsgResponse | OpReply> {
     try {
       this.dataEvents = onData(this.messageStream);
       for await (const message of this.dataEvents) {
@@ -684,21 +731,38 @@ export class CryptoConnection extends Connection {
     this.autoEncrypter = options.autoEncrypter;
   }
 
-  /** @internal @override */
-  override async command(
+  public override async command<T extends MongoDBResponseConstructor>(
+    ns: MongoDBNamespace,
+    command: Document,
+    options: CommandOptions | undefined,
+    responseType: T
+  ): Promise<InstanceType<T>>;
+
+  public override async command(
+    ns: MongoDBNamespace,
+    command: Document,
+    options?: CommandOptions
+  ): Promise<Document>;
+
+  override async command<T extends MongoDBResponseConstructor>(
     ns: MongoDBNamespace,
     cmd: Document,
-    options: CommandOptions
+    options?: CommandOptions,
+    _responseType?: T | undefined
   ): Promise<Document> {
     const { autoEncrypter } = this;
     if (!autoEncrypter) {
-      throw new MongoMissingDependencyError('No AutoEncrypter available for encryption');
+      // TODO(NODE-6065): throw a MongoRuntimeError in Node V7
+      // @ts-expect-error No cause provided because there is no underlying error.
+      throw new MongoMissingDependencyError('No AutoEncrypter available for encryption', {
+        dependencyName: 'n/a'
+      });
     }
 
     const serverWireVersion = maxWireVersion(this);
     if (serverWireVersion === 0) {
       // This means the initial handshake hasn't happened yet
-      return super.command(ns, cmd, options);
+      return await super.command<T>(ns, cmd, options, undefined);
     }
 
     if (serverWireVersion < 8) {
@@ -732,8 +796,8 @@ export class CryptoConnection extends Connection {
       }
     }
 
-    const response = await super.command(ns, encrypted, options);
+    const response = await super.command<T>(ns, encrypted, options, undefined);
 
-    return autoEncrypter.decrypt(response, options);
+    return await autoEncrypter.decrypt(response, options);
   }
 }

package/src/cmap/connection_pool.ts

@@ -26,13 +26,8 @@ import {
 } from '../error';
 import { CancellationToken, TypedEventEmitter } from '../mongo_types';
 import type { Server } from '../sdam/server';
-import {
-  type Callback,
-  List,
-  makeCounter,
-  promiseWithResolvers,
-  TimeoutController
-} from '../utils';
+import { Timeout, TimeoutError } from '../timeout';
+import { type Callback, List, makeCounter, promiseWithResolvers } from '../utils';
 import { connect } from './connect';
 import { Connection, type ConnectionEvents, type ConnectionOptions } from './connection';
 import {
@@ -107,7 +102,7 @@ export interface ConnectionPoolOptions extends Omit<ConnectionOptions, 'id' | 'g
 export interface WaitQueueMember {
   resolve: (conn: Connection) => void;
   reject: (err: AnyError) => void;
-  timeoutController: TimeoutController;
+  timeout: Timeout;
   [kCancelled]?: boolean;
 }
 
@@ -368,33 +363,40 @@ export class ConnectionPool extends TypedEventEmitter<ConnectionPoolEvents> {
     const waitQueueTimeoutMS = this.options.waitQueueTimeoutMS;
 
     const { promise, resolve, reject } = promiseWithResolvers<Connection>();
+
+    const timeout = Timeout.expires(waitQueueTimeoutMS);
+
     const waitQueueMember: WaitQueueMember = {
       resolve,
       reject,
-      timeoutController: new TimeoutController(waitQueueTimeoutMS)
+      timeout
     };
-    waitQueueMember.timeoutController.signal.addEventListener('abort', () => {
-      waitQueueMember[kCancelled] = true;
-      waitQueueMember.timeoutController.clear();
 
-      this.emitAndLog(
-        ConnectionPool.CONNECTION_CHECK_OUT_FAILED,
-        new ConnectionCheckOutFailedEvent(this, 'timeout')
-      );
-      waitQueueMember.reject(
-        new WaitQueueTimeoutError(
+    this[kWaitQueue].push(waitQueueMember);
+    process.nextTick(() => this.processWaitQueue());
+
+    try {
+      return await Promise.race([promise, waitQueueMember.timeout]);
+    } catch (error) {
+      if (TimeoutError.is(error)) {
+        waitQueueMember[kCancelled] = true;
+
+        waitQueueMember.timeout.clear();
+
+        this.emitAndLog(
+          ConnectionPool.CONNECTION_CHECK_OUT_FAILED,
+          new ConnectionCheckOutFailedEvent(this, 'timeout')
+        );
+        const timeoutError = new WaitQueueTimeoutError(
           this.loadBalanced
             ? this.waitQueueErrorMetrics()
             : 'Timed out while checking out a connection from connection pool',
           this.address
-        )
-      );
-    });
-
-    this[kWaitQueue].push(waitQueueMember);
-    process.nextTick(() => this.processWaitQueue());
-
-    return promise;
+        );
+        throw timeoutError;
+      }
+      throw error;
+    }
   }
 
   /**
@@ -631,6 +633,7 @@ export class ConnectionPool extends TypedEventEmitter<ConnectionPoolEvents> {
       new ConnectionCreatedEvent(this, { id: connectOptions.id })
     );
 
+    // eslint-disable-next-line github/no-then
     connect(connectOptions).then(
       connection => {
         // The pool might have closed since we started trying to create a connection
@@ -757,7 +760,7 @@ export class ConnectionPool extends TypedEventEmitter<ConnectionPoolEvents> {
           ConnectionPool.CONNECTION_CHECK_OUT_FAILED,
           new ConnectionCheckOutFailedEvent(this, reason, error)
         );
-        waitQueueMember.timeoutController.clear();
+        waitQueueMember.timeout.clear();
         this[kWaitQueue].shift();
         waitQueueMember.reject(error);
         continue;
@@ -778,7 +781,7 @@ export class ConnectionPool extends TypedEventEmitter<ConnectionPoolEvents> {
           ConnectionPool.CONNECTION_CHECKED_OUT,
           new ConnectionCheckedOutEvent(this, connection)
         );
-        waitQueueMember.timeoutController.clear();
+        waitQueueMember.timeout.clear();
 
         this[kWaitQueue].shift();
         waitQueueMember.resolve(connection);
@@ -817,7 +820,7 @@ export class ConnectionPool extends TypedEventEmitter<ConnectionPoolEvents> {
             waitQueueMember.resolve(connection);
           }
 
-          waitQueueMember.timeoutController.clear();
+          waitQueueMember.timeout.clear();
         }
         process.nextTick(() => this.processWaitQueue());
       });

package/src/cmap/handshake/client_metadata.ts

@@ -1,10 +1,10 @@
-import { promises as fs } from 'fs';
 import * as os from 'os';
 import * as process from 'process';
 
 import { BSON, type Document, Int32 } from '../../bson';
 import { MongoInvalidArgumentError } from '../../error';
 import type { MongoOptions } from '../../mongo_client';
+import { fileIsAccessible } from '../../utils';
 
 // eslint-disable-next-line @typescript-eslint/no-var-requires
 const NODE_DRIVER_VERSION = require('../../../package.json').version;
@@ -160,10 +160,7 @@ let dockerPromise: Promise<boolean>;
 /** @internal */
 async function getContainerMetadata() {
   const containerMetadata: Record<string, any> = {};
-  dockerPromise ??= fs.access('/.dockerenv').then(
-    () => true,
-    () => false
-  );
+  dockerPromise ??= fileIsAccessible('/.dockerenv');
   const isDocker = await dockerPromise;
 
   const { KUBERNETES_SERVICE_HOST = '' } = process.env;

package/src/cmap/wire_protocol/compression.ts

@@ -8,7 +8,7 @@ import {
   type MessageHeader,
   OpCompressedRequest,
   OpMsgResponse,
-  OpQueryResponse,
+  OpReply,
   type WriteProtocolMessageType
 } from '../commands';
 import { OP_COMPRESSED, OP_MSG } from './constants';
@@ -45,7 +45,7 @@ const ZSTD_COMPRESSION_LEVEL = 3;
 const zlibInflate = promisify(zlib.inflate.bind(zlib));
 const zlibDeflate = promisify(zlib.deflate.bind(zlib));
 
-let zstd: typeof ZStandard;
+let zstd: ZStandard;
 let Snappy: SnappyLib | null = null;
 function loadSnappy() {
   if (Snappy == null) {
@@ -67,20 +67,20 @@ export async function compress(
   switch (options.agreedCompressor) {
     case 'snappy': {
       Snappy ??= loadSnappy();
-      return Snappy.compress(dataToBeCompressed);
+      return await Snappy.compress(dataToBeCompressed);
     }
     case 'zstd': {
       loadZstd();
       if ('kModuleError' in zstd) {
         throw zstd['kModuleError'];
       }
-      return zstd.compress(dataToBeCompressed, ZSTD_COMPRESSION_LEVEL);
+      return await zstd.compress(dataToBeCompressed, ZSTD_COMPRESSION_LEVEL);
     }
     case 'zlib': {
       if (options.zlibCompressionLevel) {
         zlibOptions.level = options.zlibCompressionLevel;
       }
-      return zlibDeflate(dataToBeCompressed, zlibOptions);
+      return await zlibDeflate(dataToBeCompressed, zlibOptions);
     }
     default: {
       throw new MongoInvalidArgumentError(
@@ -106,17 +106,17 @@ export async function decompress(compressorID: number, compressedData: Buffer):
   switch (compressorID) {
     case Compressor.snappy: {
       Snappy ??= loadSnappy();
-      return Snappy.uncompress(compressedData, { asBuffer: true });
+      return await Snappy.uncompress(compressedData, { asBuffer: true });
     }
     case Compressor.zstd: {
       loadZstd();
       if ('kModuleError' in zstd) {
         throw zstd['kModuleError'];
       }
-      return zstd.decompress(compressedData);
+      return await zstd.decompress(compressedData);
     }
     case Compressor.zlib: {
-      return zlibInflate(compressedData);
+      return await zlibInflate(compressedData);
     }
     default: {
       return compressedData;
@@ -163,9 +163,7 @@ export async function compressCommand(
  *
  * This method does not parse the response's BSON.
  */
-export async function decompressResponse(
-  message: Buffer
-): Promise<OpMsgResponse | OpQueryResponse> {
+export async function decompressResponse(message: Buffer): Promise<OpMsgResponse | OpReply> {
   const messageHeader: MessageHeader = {
     length: message.readInt32LE(0),
     requestId: message.readInt32LE(4),
@@ -174,7 +172,7 @@ export async function decompressResponse(
   };
 
   if (messageHeader.opCode !== OP_COMPRESSED) {
-    const ResponseType = messageHeader.opCode === OP_MSG ? OpMsgResponse : OpQueryResponse;
+    const ResponseType = messageHeader.opCode === OP_MSG ? OpMsgResponse : OpReply;
     const messageBody = message.subarray(MESSAGE_HEADER_SIZE);
     return new ResponseType(message, messageHeader, messageBody);
   }
@@ -189,7 +187,7 @@ export async function decompressResponse(
   const compressedBuffer = message.slice(MESSAGE_HEADER_SIZE + 9);
 
   // recalculate based on wrapped opcode
-  const ResponseType = header.opCode === OP_MSG ? OpMsgResponse : OpQueryResponse;
+  const ResponseType = header.opCode === OP_MSG ? OpMsgResponse : OpReply;
   const messageBody = await decompress(compressorID, compressedBuffer);
   if (messageBody.length !== header.length) {
     throw new MongoDecompressionError('Message body and message header must be the same length');