mongodb 4.3.1 → 4.5.0

package/src/cmap/connection.ts

@@ -33,7 +33,7 @@ import {
   now,
   uuidV4
 } from '../utils';
-import type { W, WriteConcern, WriteConcernOptions } from '../write_concern';
+import type { WriteConcern } from '../write_concern';
 import type { MongoCredentials } from './auth/mongo_credentials';
 import {
   CommandFailedEvent,
@@ -75,6 +75,8 @@ const kHello = Symbol('hello');
 const kAutoEncrypter = Symbol('autoEncrypter');
 /** @internal */
 const kFullResult = Symbol('fullResult');
+/** @internal */
+const kDelayedTimeoutId = Symbol('delayedTimeoutId');
 
 /** @internal */
 export interface QueryOptions extends BSONSerializeOptions {
@@ -109,11 +111,14 @@ export interface CommandOptions extends BSONSerializeOptions {
   noResponse?: boolean;
   omitReadPreference?: boolean;
 
-  // FIXME: NODE-2802
+  // TODO(NODE-2802): Currently the CommandOptions take a property willRetryWrite which is a hint
+  // from executeOperation that the txnNum should be applied to this command.
+  // Applying a session to a command should happen as part of command construction,
+  // most likely in the CommandOperation#executeCommand method, where we have access to
+  // the details we need to determine if a txnNum should also be applied.
   willRetryWrite?: boolean;
 
-  // FIXME: NODE-2781
-  writeConcern?: WriteConcernOptions | WriteConcern | W;
+  writeConcern?: WriteConcern;
 }
 
 /** @internal */
@@ -121,7 +126,15 @@ export interface GetMoreOptions extends CommandOptions {
   batchSize?: number;
   maxTimeMS?: number;
   maxAwaitTimeMS?: number;
-  comment?: Document | string;
+  /**
+   * Comment to apply to the operation.
+   *
+   * In server versions pre-4.4, 'comment' must be string.  A server
+   * error will be thrown if any other type is provided.
+   *
+   * In server versions 4.4 and above, 'comment' can be any valid BSON type.
+   */
+  comment?: unknown;
 }
 
 /** @public */
@@ -188,6 +201,9 @@ export class Connection extends TypedEventEmitter<ConnectionEvents> {
   lastHelloMS?: number;
   serverApi?: ServerApi;
   helloOk?: boolean;
+
+  /**@internal */
+  [kDelayedTimeoutId]: NodeJS.Timeout | null;
   /** @internal */
   [kDescription]: StreamDescription;
   /** @internal */
@@ -201,9 +217,9 @@ export class Connection extends TypedEventEmitter<ConnectionEvents> {
   /** @internal */
   [kStream]: Stream;
   /** @internal */
-  [kHello]: Document;
+  [kHello]: Document | null;
   /** @internal */
-  [kClusterTime]: Document;
+  [kClusterTime]: Document | null;
 
   /** @event */
   static readonly COMMAND_STARTED = COMMAND_STARTED;
@@ -231,6 +247,8 @@ export class Connection extends TypedEventEmitter<ConnectionEvents> {
     this.serverApi = options.serverApi;
     this.closed = false;
     this.destroyed = false;
+    this[kHello] = null;
+    this[kClusterTime] = null;
 
     this[kDescription] = new StreamDescription(this.address, options);
     this[kGeneration] = options.generation;
@@ -242,31 +260,33 @@ export class Connection extends TypedEventEmitter<ConnectionEvents> {
       ...options,
       maxBsonMessageSize: this.hello?.maxBsonMessageSize
     });
-    this[kMessageStream].on('message', messageHandler(this));
     this[kStream] = stream;
-    stream.on('error', () => {
+
+    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 */
     });
 
-    this[kMessageStream].on('error', error => this.handleIssue({ destroy: error }));
-    stream.on('close', () => this.handleIssue({ isClose: true }));
-    stream.on('timeout', () => this.handleIssue({ isTimeout: true, destroy: true }));
-
     // hook the message stream up to the passed in stream
-    stream.pipe(this[kMessageStream]);
-    this[kMessageStream].pipe(stream);
+    this[kStream].pipe(this[kMessageStream]);
+    this[kMessageStream].pipe(this[kStream]);
   }
 
   get description(): StreamDescription {
     return this[kDescription];
   }
 
-  get hello(): Document {
+  get hello(): Document | null {
     return this[kHello];
   }
 
   // the `connect` method stores the result of the handshake hello on the connection
-  set hello(response: Document) {
+  set hello(response: Document | null) {
     this[kDescription].receiveResponse(response);
     this[kDescription] = Object.freeze(this[kDescription]);
 
@@ -294,7 +314,7 @@ export class Connection extends TypedEventEmitter<ConnectionEvents> {
     return calculateDurationInMs(this[kLastUseTime]);
   }
 
-  get clusterTime(): Document {
+  get clusterTime(): Document | null {
     return this[kClusterTime];
   }
 
@@ -306,40 +326,133 @@ export class Connection extends TypedEventEmitter<ConnectionEvents> {
     this[kLastUseTime] = now();
   }
 
-  handleIssue(issue: { isTimeout?: boolean; isClose?: boolean; destroy?: boolean | Error }): void {
+  onError(error: Error) {
     if (this.closed) {
       return;
     }
 
-    if (issue.destroy) {
-      this[kStream].destroy(typeof issue.destroy === 'boolean' ? undefined : issue.destroy);
+    this[kStream].destroy(error);
+
+    this.closed = true;
+
+    for (const op of this[kQueue].values()) {
+      op.cb(error);
+    }
+
+    this[kQueue].clear();
+    this.emit(Connection.CLOSE);
+  }
+
+  onClose() {
+    if (this.closed) {
+      return;
     }
 
     this.closed = true;
 
-    for (const [, op] of this[kQueue]) {
-      if (issue.isTimeout) {
-        op.cb(
-          new MongoNetworkTimeoutError(`connection ${this.id} to ${this.address} timed out`, {
-            beforeHandshake: this.hello == null
-          })
-        );
-      } else if (issue.isClose) {
-        op.cb(new MongoNetworkError(`connection ${this.id} to ${this.address} closed`));
-      } else {
-        op.cb(typeof issue.destroy === 'boolean' ? undefined : issue.destroy);
-      }
+    const message = `connection ${this.id} to ${this.address} closed`;
+    for (const op of this[kQueue].values()) {
+      op.cb(new MongoNetworkError(message));
     }
 
     this[kQueue].clear();
     this.emit(Connection.CLOSE);
   }
 
-  destroy(): void;
-  destroy(callback: Callback): void;
-  destroy(options: DestroyOptions): void;
-  destroy(options: DestroyOptions, callback: Callback): void;
-  destroy(options?: DestroyOptions | Callback, callback?: Callback): void {
+  onTimeout() {
+    if (this.closed) {
+      return;
+    }
+
+    this[kDelayedTimeoutId] = setTimeout(() => {
+      this[kStream].destroy();
+
+      this.closed = true;
+
+      const message = `connection ${this.id} to ${this.address} timed out`;
+      const beforeHandshake = this.hello == null;
+      for (const op of this[kQueue].values()) {
+        op.cb(new MongoNetworkTimeoutError(message, { beforeHandshake }));
+      }
+
+      this[kQueue].clear();
+      this.emit(Connection.CLOSE);
+    }, 1).unref(); // No need for this timer to hold the event loop open
+  }
+
+  onMessage(message: BinMsg | Response) {
+    const delayedTimeoutId = this[kDelayedTimeoutId];
+    if (delayedTimeoutId != null) {
+      clearTimeout(delayedTimeoutId);
+      this[kDelayedTimeoutId] = null;
+    }
+
+    // always emit the message, in case we are streaming
+    this.emit('message', message);
+    const operationDescription = this[kQueue].get(message.responseTo);
+    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) {
+      // requeue the callback for next synthetic request
+      this[kQueue].set(message.requestId, operationDescription);
+    } else if (operationDescription.socketTimeoutOverride) {
+      this[kStream].setTimeout(this.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: Document = message.documents[0];
+      const session = operationDescription.session;
+      if (session) {
+        updateSessionFromResponse(session, document);
+      }
+
+      if (document.$clusterTime) {
+        this[kClusterTime] = document.$clusterTime;
+        this.emit(Connection.CLUSTER_TIME_RECEIVED, document.$clusterTime);
+      }
+
+      if (operationDescription.command) {
+        if (document.writeConcernError) {
+          callback(new MongoWriteConcernError(document.writeConcernError, document));
+          return;
+        }
+
+        if (document.ok === 0 || document.$err || document.errmsg || document.code) {
+          callback(new MongoServerError(document));
+          return;
+        }
+      } else {
+        // Pre 3.2 support
+        if (document.ok === 0 || document.$err || document.errmsg) {
+          callback(new MongoServerError(document));
+          return;
+        }
+      }
+    }
+
+    callback(undefined, operationDescription.fullResult ? message : message.documents[0]);
+  }
+
+  destroy(options?: DestroyOptions, callback?: Callback): void {
     if (typeof options === 'function') {
       callback = options;
       options = { force: false };
@@ -376,7 +489,6 @@ export class Connection extends TypedEventEmitter<ConnectionEvents> {
     });
   }
 
-  /** @internal */
   command(
     ns: MongoDBNamespace,
     cmd: Document,
@@ -453,7 +565,6 @@ export class Connection extends TypedEventEmitter<ConnectionEvents> {
     }
   }
 
-  /** @internal */
   query(ns: MongoDBNamespace, cmd: Document, options: QueryOptions, callback: Callback): void {
     const isExplain = cmd.$explain != null;
     const readPreference = options.readPreference ?? ReadPreference.primary;
@@ -526,7 +637,6 @@ export class Connection extends TypedEventEmitter<ConnectionEvents> {
     );
   }
 
-  /** @internal */
   getMore(
     ns: MongoDBNamespace,
     cursorId: Long,
@@ -571,6 +681,11 @@ export class Connection extends TypedEventEmitter<ConnectionEvents> {
     if (typeof options.maxAwaitTimeMS === 'number') {
       getMoreCmd.maxTimeMS = options.maxAwaitTimeMS;
     }
+    // we check for undefined specifically here to allow falsy values
+    // eslint-disable-next-line no-restricted-syntax
+    if (options.comment !== undefined) {
+      getMoreCmd.comment = options.comment;
+    }
 
     const commandOptions = Object.assign(
       {
@@ -583,7 +698,6 @@ export class Connection extends TypedEventEmitter<ConnectionEvents> {
     this.command(ns, getMoreCmd, commandOptions, callback);
   }
 
-  /** @internal */
   killCursors(
     ns: MongoDBNamespace,
     cursorIds: Long[],
@@ -646,7 +760,12 @@ export class CryptoConnection extends Connection {
   }
 
   /** @internal @override */
-  command(ns: MongoDBNamespace, cmd: Document, options: CommandOptions, callback: Callback): void {
+  override command(
+    ns: MongoDBNamespace,
+    cmd: Document,
+    options: CommandOptions,
+    callback: Callback
+  ): void {
     const autoEncrypter = this[kAutoEncrypter];
     if (!autoEncrypter) {
       return callback(new MongoMissingDependencyError('No AutoEncrypter available for encryption'));
@@ -698,74 +817,6 @@ function supportsOpMsg(conn: Connection) {
   return maxWireVersion(conn) >= 6 && !description.__nodejs_mock_server__;
 }
 
-function messageHandler(conn: Connection) {
-  return function messageHandler(message: BinMsg | Response) {
-    // always emit the message, in case we are streaming
-    conn.emit('message', message);
-    const operationDescription = conn[kQueue].get(message.responseTo);
-    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
-    conn[kQueue].delete(message.responseTo);
-    if ('moreToCome' in message && message.moreToCome) {
-      // requeue the callback for next synthetic request
-      conn[kQueue].set(message.requestId, operationDescription);
-    } else if (operationDescription.socketTimeoutOverride) {
-      conn[kStream].setTimeout(conn.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: Document = message.documents[0];
-      const session = operationDescription.session;
-      if (session) {
-        updateSessionFromResponse(session, document);
-      }
-
-      if (document.$clusterTime) {
-        conn[kClusterTime] = document.$clusterTime;
-        conn.emit(Connection.CLUSTER_TIME_RECEIVED, document.$clusterTime);
-      }
-
-      if (operationDescription.command) {
-        if (document.writeConcernError) {
-          callback(new MongoWriteConcernError(document.writeConcernError, document));
-          return;
-        }
-
-        if (document.ok === 0 || document.$err || document.errmsg || document.code) {
-          callback(new MongoServerError(document));
-          return;
-        }
-      } else {
-        // Pre 3.2 support
-        if (document.ok === 0 || document.$err || document.errmsg) {
-          callback(new MongoServerError(document));
-          return;
-        }
-      }
-    }
-
-    callback(undefined, operationDescription.fullResult ? message : message.documents[0]);
-  };
-}
-
 function streamIdentifier(stream: Stream, options: ConnectionOptions): string {
   if (options.proxyHost) {
     // If proxy options are specified, the properties of `stream` itself

package/src/cmap/errors.ts

@@ -14,7 +14,7 @@ export class PoolClosedError extends MongoDriverError {
     this.address = pool.address;
   }
 
-  get name(): string {
+  override get name(): string {
     return 'MongoPoolClosedError';
   }
 }
@@ -32,7 +32,7 @@ export class WaitQueueTimeoutError extends MongoDriverError {
     this.address = address;
   }
 
-  get name(): string {
+  override get name(): string {
     return 'MongoWaitQueueTimeoutError';
   }
 }

package/src/cmap/message_stream.ts

@@ -60,12 +60,12 @@ export class MessageStream extends Duplex {
     this[kBuffer] = new BufferPool();
   }
 
-  _write(chunk: Buffer, _: unknown, callback: Callback<Buffer>): void {
+  override _write(chunk: Buffer, _: unknown, callback: Callback<Buffer>): void {
     this[kBuffer].append(chunk);
     processIncomingData(this, callback);
   }
 
-  _read(/* size */): void {
+  override _read(/* size */): void {
     // NOTE: This implementation is empty because we explicitly push data to be read
     //       when `writeMessage` is called.
     return;

package/src/cmap/stream_description.ts

@@ -53,7 +53,10 @@ export class StreamDescription {
         : [];
   }
 
-  receiveResponse(response: Document): void {
+  receiveResponse(response: Document | null): void {
+    if (response == null) {
+      return;
+    }
     this.type = parseServerType(response);
     for (const field of RESPONSE_FIELDS) {
       if (response[field] != null) {