mongodb 4.4.1 → 4.5.0

package/src/operations/execute_operation.ts

@@ -1,14 +1,16 @@
 import type { Document } from '../bson';
 import {
-  isRetryableError,
+  isRetryableReadError,
   MongoCompatibilityError,
   MONGODB_ERROR_CODES,
   MongoError,
+  MongoErrorLabel,
   MongoExpiredSessionError,
   MongoNetworkError,
   MongoRuntimeError,
   MongoServerError,
-  MongoTransactionError
+  MongoTransactionError,
+  MongoUnexpectedServerResponseError
 } from '../error';
 import { ReadPreference } from '../read_preference';
 import type { Server } from '../sdam/server';
@@ -19,7 +21,13 @@ import {
 } from '../sdam/server_selection';
 import type { Topology } from '../sdam/topology';
 import type { ClientSession } from '../sessions';
-import { Callback, maxWireVersion, maybePromise, supportsRetryableWrites } from '../utils';
+import {
+  Callback,
+  getTopology,
+  maybePromise,
+  supportsRetryableWrites,
+  TopologyProvider
+} from '../utils';
 import { AbstractOperation, Aspect } from './operation';
 
 const MMAPv1_RETRY_WRITES_ERROR_CODE = MONGODB_ERROR_CODES.IllegalOperation;
@@ -58,99 +66,101 @@ export interface ExecutionResult {
 export function executeOperation<
   T extends AbstractOperation<TResult>,
   TResult = ResultTypeFromOperation<T>
->(topology: Topology, operation: T): Promise<TResult>;
+>(topologyProvider: TopologyProvider, operation: T): Promise<TResult>;
 export function executeOperation<
   T extends AbstractOperation<TResult>,
   TResult = ResultTypeFromOperation<T>
->(topology: Topology, operation: T, callback: Callback<TResult>): void;
+>(topologyProvider: TopologyProvider, operation: T, callback: Callback<TResult>): void;
 export function executeOperation<
   T extends AbstractOperation<TResult>,
   TResult = ResultTypeFromOperation<T>
->(topology: Topology, operation: T, callback?: Callback<TResult>): Promise<TResult> | void;
+>(
+  topologyProvider: TopologyProvider,
+  operation: T,
+  callback?: Callback<TResult>
+): Promise<TResult> | void;
 export function executeOperation<
   T extends AbstractOperation<TResult>,
   TResult = ResultTypeFromOperation<T>
->(topology: Topology, operation: T, callback?: Callback<TResult>): Promise<TResult> | void {
+>(
+  topologyProvider: TopologyProvider,
+  operation: T,
+  callback?: Callback<TResult>
+): Promise<TResult> | void {
   if (!(operation instanceof AbstractOperation)) {
-    // TODO(NODE-3483)
+    // TODO(NODE-3483): Extend MongoRuntimeError
     throw new MongoRuntimeError('This method requires a valid operation instance');
   }
 
-  return maybePromise(callback, cb => {
+  return maybePromise(callback, callback => {
+    let topology: Topology;
+    try {
+      topology = getTopology(topologyProvider);
+    } catch (error) {
+      return callback(error);
+    }
     if (topology.shouldCheckForSessionSupport()) {
-      return topology.selectServer(ReadPreference.primaryPreferred, err => {
-        if (err) return cb(err);
+      return topology.selectServer(ReadPreference.primaryPreferred, {}, err => {
+        if (err) return callback(err);
 
-        executeOperation<T, TResult>(topology, operation, cb);
+        executeOperation<T, TResult>(topologyProvider, operation, callback);
       });
     }
 
     // The driver sessions spec mandates that we implicitly create sessions for operations
     // that are not explicitly provided with a session.
-    let session: ClientSession | undefined = operation.session;
+    let session = operation.session;
     let owner: symbol | undefined;
     if (topology.hasSessionSupport()) {
       if (session == null) {
         owner = Symbol();
         session = topology.startSession({ owner, explicit: false });
       } else if (session.hasEnded) {
-        return cb(new MongoExpiredSessionError('Use of expired sessions is not permitted'));
+        return callback(new MongoExpiredSessionError('Use of expired sessions is not permitted'));
       } else if (session.snapshotEnabled && !topology.capabilities.supportsSnapshotReads) {
-        return cb(new MongoCompatibilityError('Snapshot reads require MongoDB 5.0 or later'));
+        return callback(new MongoCompatibilityError('Snapshot reads require MongoDB 5.0 or later'));
       }
     } else if (session) {
       // If the user passed an explicit session and we are still, after server selection,
       // trying to run against a topology that doesn't support sessions we error out.
-      return cb(new MongoCompatibilityError('Current topology does not support sessions'));
+      return callback(new MongoCompatibilityError('Current topology does not support sessions'));
     }
 
     try {
-      executeWithServerSelection(topology, session, operation, (err, result) => {
-        if (session && session.owner && session.owner === owner) {
-          return session.endSession(err2 => cb(err2 || err, result));
+      executeWithServerSelection<TResult>(topology, session, operation, (error, result) => {
+        if (session?.owner != null && session.owner === owner) {
+          return session.endSession(endSessionError => callback(endSessionError ?? error, result));
         }
 
-        cb(err, result);
+        callback(error, result);
       });
-    } catch (e) {
-      if (session && session.owner && session.owner === owner) {
+    } catch (error) {
+      if (session?.owner != null && session.owner === owner) {
         session.endSession();
       }
-
-      throw e;
+      throw error;
     }
   });
 }
 
-function supportsRetryableReads(server: Server) {
-  return maxWireVersion(server) >= 6;
-}
-
-function executeWithServerSelection(
+function executeWithServerSelection<TResult>(
   topology: Topology,
-  session: ClientSession,
+  session: ClientSession | undefined,
   operation: AbstractOperation,
-  callback: Callback
+  callback: Callback<TResult>
 ) {
-  const readPreference = operation.readPreference || ReadPreference.primary;
-  const inTransaction = session && session.inTransaction();
+  const readPreference = operation.readPreference ?? ReadPreference.primary;
+  const inTransaction = !!session?.inTransaction();
 
   if (inTransaction && !readPreference.equals(ReadPreference.primary)) {
-    callback(
+    return callback(
       new MongoTransactionError(
         `Read preference in a transaction must be primary, not: ${readPreference.mode}`
       )
     );
-
-    return;
   }
 
-  if (
-    session &&
-    session.isPinned &&
-    session.transaction.isCommitted &&
-    !operation.bypassPinningCheck
-  ) {
+  if (session?.isPinned && session.transaction.isCommitted && !operation.bypassPinningCheck) {
     session.unpin();
   }
 
@@ -170,60 +180,54 @@ function executeWithServerSelection(
   }
 
   const serverSelectionOptions = { session };
-  function callbackWithRetry(err?: any, result?: any) {
-    if (err == null) {
-      return callback(undefined, result);
-    }
+  function retryOperation(originalError: MongoError) {
+    const isWriteOperation = operation.hasAspect(Aspect.WRITE_OPERATION);
+    const isReadOperation = operation.hasAspect(Aspect.READ_OPERATION);
 
-    const hasReadAspect = operation.hasAspect(Aspect.READ_OPERATION);
-    const hasWriteAspect = operation.hasAspect(Aspect.WRITE_OPERATION);
-    const itShouldRetryWrite = shouldRetryWrite(err);
-
-    if ((hasReadAspect && !isRetryableError(err)) || (hasWriteAspect && !itShouldRetryWrite)) {
-      return callback(err);
-    }
-
-    if (
-      hasWriteAspect &&
-      itShouldRetryWrite &&
-      err.code === MMAPv1_RETRY_WRITES_ERROR_CODE &&
-      err.errmsg.match(/Transaction numbers/)
-    ) {
-      callback(
+    if (isWriteOperation && originalError.code === MMAPv1_RETRY_WRITES_ERROR_CODE) {
+      return callback(
         new MongoServerError({
           message: MMAPv1_RETRY_WRITES_ERROR_MESSAGE,
           errmsg: MMAPv1_RETRY_WRITES_ERROR_MESSAGE,
-          originalError: err
+          originalError
         })
       );
+    }
 
-      return;
+    if (isWriteOperation && !originalError.hasErrorLabel(MongoErrorLabel.RetryableWriteError)) {
+      return callback(originalError);
     }
 
-    // select a new server, and attempt to retry the operation
-    topology.selectServer(selector, serverSelectionOptions, (e?: any, server?: any) => {
-      if (
-        e ||
-        (operation.hasAspect(Aspect.READ_OPERATION) && !supportsRetryableReads(server)) ||
-        (operation.hasAspect(Aspect.WRITE_OPERATION) && !supportsRetryableWrites(server))
-      ) {
-        callback(e);
-        return;
-      }
+    if (isReadOperation && !isRetryableReadError(originalError)) {
+      return callback(originalError);
+    }
 
+    if (
+      originalError instanceof MongoNetworkError &&
+      session?.isPinned &&
+      !session.inTransaction() &&
+      operation.hasAspect(Aspect.CURSOR_CREATING)
+    ) {
       // If we have a cursor and the initial command fails with a network error,
       // we can retry it on another connection. So we need to check it back in, clear the
       // pool for the service id, and retry again.
-      if (
-        err &&
-        err instanceof MongoNetworkError &&
-        server.loadBalanced &&
-        session &&
-        session.isPinned &&
-        !session.inTransaction() &&
-        operation.hasAspect(Aspect.CURSOR_CREATING)
-      ) {
-        session.unpin({ force: true, forceClear: true });
+      session.unpin({ force: true, forceClear: true });
+    }
+
+    // select a new server, and attempt to retry the operation
+    topology.selectServer(selector, serverSelectionOptions, (error?: Error, server?: Server) => {
+      if (!error && isWriteOperation && !supportsRetryableWrites(server)) {
+        return callback(
+          new MongoUnexpectedServerResponseError(
+            'Selected server does not support retryable writes'
+          )
+        );
+      }
+
+      if (error || !server) {
+        return callback(
+          error ?? new MongoUnexpectedServerResponseError('Server selection failed without error')
+        );
       }
 
       operation.execute(server, session, callback);
@@ -233,8 +237,7 @@ function executeWithServerSelection(
   if (
     readPreference &&
     !readPreference.equals(ReadPreference.primary) &&
-    session &&
-    session.inTransaction()
+    session?.inTransaction()
   ) {
     callback(
       new MongoTransactionError(
@@ -246,21 +249,17 @@ function executeWithServerSelection(
   }
 
   // select a server, and execute the operation against it
-  topology.selectServer(selector, serverSelectionOptions, (err?: any, server?: any) => {
-    if (err) {
-      callback(err);
-      return;
+  topology.selectServer(selector, serverSelectionOptions, (error, server) => {
+    if (error || !server) {
+      return callback(error);
     }
 
     if (session && operation.hasAspect(Aspect.RETRYABLE)) {
       const willRetryRead =
-        topology.s.options.retryReads !== false &&
-        !inTransaction &&
-        supportsRetryableReads(server) &&
-        operation.canRetryRead;
+        topology.s.options.retryReads && !inTransaction && operation.canRetryRead;
 
       const willRetryWrite =
-        topology.s.options.retryWrites === true &&
+        topology.s.options.retryWrites &&
         !inTransaction &&
         supportsRetryableWrites(server) &&
         operation.canRetryWrite;
@@ -274,15 +273,17 @@ function executeWithServerSelection(
           session.incrementTransactionNumber();
         }
 
-        operation.execute(server, session, callbackWithRetry);
-        return;
+        return operation.execute(server, session, (error, result) => {
+          if (error instanceof MongoError) {
+            return retryOperation(error);
+          } else if (error) {
+            return callback(error);
+          }
+          callback(undefined, result);
+        });
       }
     }
 
-    operation.execute(server, session, callback);
+    return operation.execute(server, session, callback);
   });
 }
-
-function shouldRetryWrite(err: any) {
-  return err instanceof MongoError && err.hasErrorLabel('RetryableWriteError');
-}

package/src/operations/find.ts

@@ -46,8 +46,6 @@ export interface FindOptions<TSchema extends Document = Document> extends Comman
   min?: Document;
   /** The exclusive upper bound for a specific index */
   max?: Document;
-  /** You can put a $comment field on a query to make looking in the profiler logs simpler. */
-  comment?: string | Document;
   /** Number of milliseconds to wait before aborting the query. */
   maxTimeMS?: number;
   /** The maximum amount of time for the server to wait on new documents to satisfy a tailable cursor query. Requires `tailable` and `awaitData` to be true */
@@ -72,7 +70,7 @@ const SUPPORTS_WRITE_CONCERN_AND_COLLATION = 5;
 
 /** @internal */
 export class FindOperation extends CommandOperation<Document> {
-  options: FindOptions;
+  override options: FindOptions;
   filter: Document;
 
   constructor(
@@ -104,7 +102,11 @@ export class FindOperation extends CommandOperation<Document> {
     this.filter = filter != null && filter._bsontype === 'ObjectID' ? { _id: filter } : filter;
   }
 
-  execute(server: Server, session: ClientSession, callback: Callback<Document>): void {
+  override execute(
+    server: Server,
+    session: ClientSession | undefined,
+    callback: Callback<Document>
+  ): void {
     this.server = server;
 
     const serverWireVersion = maxWireVersion(server);
@@ -237,7 +239,9 @@ function makeFindCommand(ns: MongoDBNamespace, filter: Document, options: FindOp
     findCommand.singleBatch = options.singleBatch;
   }
 
-  if (options.comment) {
+  // we check for undefined specifically here to allow falsy values
+  // eslint-disable-next-line no-restricted-syntax
+  if (options.comment !== undefined) {
     findCommand.comment = options.comment;
   }
 

package/src/operations/find_and_modify.ts

@@ -82,6 +82,15 @@ interface FindAndModifyCmdBase {
   maxTimeMS?: number;
   let?: Document;
   writeConcern?: WriteConcern | WriteConcernSettings;
+  /**
+   * 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;
 }
 
 function configureFindAndModifyCmdBaseUpdateOpts(
@@ -99,7 +108,7 @@ function configureFindAndModifyCmdBaseUpdateOpts(
 
 /** @internal */
 class FindAndModifyOperation extends CommandOperation<Document> {
-  options: FindOneAndReplaceOptions | FindOneAndUpdateOptions | FindOneAndDeleteOptions;
+  override options: FindOneAndReplaceOptions | FindOneAndUpdateOptions | FindOneAndDeleteOptions;
   cmdBase: FindAndModifyCmdBase;
   collection: Collection;
   query: Document;
@@ -140,6 +149,12 @@ class FindAndModifyOperation extends CommandOperation<Document> {
       this.cmdBase.let = options.let;
     }
 
+    // we check for undefined specifically here to allow falsy values
+    // eslint-disable-next-line no-restricted-syntax
+    if (options.comment !== undefined) {
+      this.cmdBase.comment = options.comment;
+    }
+
     // force primary read preference
     this.readPreference = ReadPreference.primary;
 
@@ -147,7 +162,11 @@ class FindAndModifyOperation extends CommandOperation<Document> {
     this.query = query;
   }
 
-  execute(server: Server, session: ClientSession, callback: Callback<Document>): void {
+  override execute(
+    server: Server,
+    session: ClientSession | undefined,
+    callback: Callback<Document>
+  ): void {
     const coll = this.collection;
     const query = this.query;
     const options = { ...this.options, ...this.bsonOptions };

package/src/operations/get_more.ts

@@ -2,7 +2,7 @@ import type { Document, Long } from '../bson';
 import { MongoRuntimeError } from '../error';
 import type { Server } from '../sdam/server';
 import type { ClientSession } from '../sessions';
-import type { Callback, MongoDBNamespace } from '../utils';
+import { Callback, maxWireVersion, MongoDBNamespace } from '../utils';
 import { AbstractOperation, Aspect, defineAspects, OperationOptions } from './operation';
 
 /**
@@ -12,8 +12,12 @@ import { AbstractOperation, Aspect, defineAspects, OperationOptions } from './op
 export interface GetMoreOptions extends OperationOptions {
   /** Set the batchSize for the getMoreCommand when iterating over the query results. */
   batchSize?: number;
-  /** You can put a $comment field on a query to make looking in the profiler logs simpler. */
-  comment?: string | Document;
+  /**
+   * Comment to apply to the operation.
+   *
+   * getMore only supports 'comment' in server versions 4.4 and above.
+   */
+  comment?: unknown;
   /** Number of milliseconds to wait before aborting the query. */
   maxTimeMS?: number;
 }
@@ -21,12 +25,18 @@ export interface GetMoreOptions extends OperationOptions {
 /** @internal */
 export class GetMoreOperation extends AbstractOperation {
   cursorId: Long;
-  options: GetMoreOptions;
-  server: Server;
+  override options: GetMoreOptions;
 
   constructor(ns: MongoDBNamespace, cursorId: Long, server: Server, options: GetMoreOptions = {}) {
     super(options);
+
     this.options = options;
+
+    // comment on getMore is only supported for server versions 4.4 and above
+    if (maxWireVersion(server) < 9) {
+      delete this.options.comment;
+    }
+
     this.ns = ns;
     this.cursorId = cursorId;
     this.server = server;
@@ -36,7 +46,11 @@ export class GetMoreOperation extends AbstractOperation {
    * Although there is a server already associated with the get more operation, the signature
    * for execute passes a server so we will just use that one.
    */
-  execute(server: Server, session: ClientSession, callback: Callback<Document>): void {
+  override execute(
+    server: Server,
+    session: ClientSession | undefined,
+    callback: Callback<Document>
+  ): void {
     if (server !== this.server) {
       return callback(
         new MongoRuntimeError('Getmore must run on the same server operation began on')