mongodb 4.3.1 → 4.5.0

package/src/operations/run_command.ts

@@ -9,7 +9,7 @@ export type RunCommandOptions = CommandOperationOptions;
 
 /** @internal */
 export class RunCommandOperation<T = Document> extends CommandOperation<T> {
-  options: RunCommandOptions;
+  override options: RunCommandOptions;
   command: Document;
 
   constructor(parent: OperationParent | undefined, command: Document, options?: RunCommandOptions) {
@@ -18,7 +18,11 @@ export class RunCommandOperation<T = Document> extends CommandOperation<T> {
     this.command = command;
   }
 
-  execute(server: Server, session: ClientSession, callback: Callback): void {
+  override execute(
+    server: Server,
+    session: ClientSession | undefined,
+    callback: Callback<T>
+  ): void {
     const command = this.command;
     this.executeCommand(server, session, command, callback);
   }

package/src/operations/set_profiling_level.ts

@@ -23,7 +23,7 @@ export type SetProfilingLevelOptions = CommandOperationOptions;
 
 /** @internal */
 export class SetProfilingLevelOperation extends CommandOperation<ProfilingLevel> {
-  options: SetProfilingLevelOptions;
+  override options: SetProfilingLevelOptions;
   level: ProfilingLevel;
   profile: 0 | 1 | 2;
 
@@ -48,7 +48,11 @@ export class SetProfilingLevelOperation extends CommandOperation<ProfilingLevel>
     this.level = level;
   }
 
-  execute(server: Server, session: ClientSession, callback: Callback<ProfilingLevel>): void {
+  override execute(
+    server: Server,
+    session: ClientSession | undefined,
+    callback: Callback<ProfilingLevel>
+  ): void {
     const level = this.level;
 
     if (!levelValues.has(level)) {

package/src/operations/stats.ts

@@ -18,7 +18,7 @@ export interface CollStatsOptions extends CommandOperationOptions {
  * @internal
  */
 export class CollStatsOperation extends CommandOperation<Document> {
-  options: CollStatsOptions;
+  override options: CollStatsOptions;
   collectionName: string;
 
   /**
@@ -33,7 +33,11 @@ export class CollStatsOperation extends CommandOperation<Document> {
     this.collectionName = collection.collectionName;
   }
 
-  execute(server: Server, session: ClientSession, callback: Callback<CollStats>): void {
+  override execute(
+    server: Server,
+    session: ClientSession | undefined,
+    callback: Callback<CollStats>
+  ): void {
     const command: Document = { collStats: this.collectionName };
     if (this.options.scale != null) {
       command.scale = this.options.scale;
@@ -51,14 +55,18 @@ export interface DbStatsOptions extends CommandOperationOptions {
 
 /** @internal */
 export class DbStatsOperation extends CommandOperation<Document> {
-  options: DbStatsOptions;
+  override options: DbStatsOptions;
 
   constructor(db: Db, options: DbStatsOptions) {
     super(db, options);
     this.options = options;
   }
 
-  execute(server: Server, session: ClientSession, callback: Callback<Document>): void {
+  override execute(
+    server: Server,
+    session: ClientSession | undefined,
+    callback: Callback<Document>
+  ): void {
     const command: Document = { dbStats: true };
     if (this.options.scale != null) {
       command.scale = this.options.scale;

package/src/operations/update.ts

@@ -63,7 +63,7 @@ export interface UpdateStatement {
 
 /** @internal */
 export class UpdateOperation extends CommandOperation<Document> {
-  options: UpdateOptions & { ordered?: boolean };
+  override options: UpdateOptions & { ordered?: boolean };
   statements: UpdateStatement[];
 
   constructor(
@@ -78,7 +78,7 @@ export class UpdateOperation extends CommandOperation<Document> {
     this.statements = statements;
   }
 
-  get canRetryWrite(): boolean {
+  override get canRetryWrite(): boolean {
     if (super.canRetryWrite === false) {
       return false;
     }
@@ -86,7 +86,11 @@ export class UpdateOperation extends CommandOperation<Document> {
     return this.statements.every(op => op.multi == null || op.multi === false);
   }
 
-  execute(server: Server, session: ClientSession, callback: Callback<Document>): void {
+  override execute(
+    server: Server,
+    session: ClientSession | undefined,
+    callback: Callback<Document>
+  ): void {
     const options = this.options ?? {};
     const ordered = typeof options.ordered === 'boolean' ? options.ordered : true;
     const command: Document = {
@@ -103,6 +107,12 @@ export class UpdateOperation extends CommandOperation<Document> {
       command.let = options.let;
     }
 
+    // we check for undefined specifically here to allow falsy values
+    // eslint-disable-next-line no-restricted-syntax
+    if (options.comment !== undefined) {
+      command.comment = options.comment;
+    }
+
     const statementWithCollation = this.statements.find(statement => !!statement.collation);
     if (
       collationNotSupported(server, options) ||
@@ -152,9 +162,9 @@ export class UpdateOneOperation extends UpdateOperation {
     }
   }
 
-  execute(
+  override execute(
     server: Server,
-    session: ClientSession,
+    session: ClientSession | undefined,
     callback: Callback<UpdateResult | Document>
   ): void {
     super.execute(server, session, (err, res) => {
@@ -189,9 +199,9 @@ export class UpdateManyOperation extends UpdateOperation {
     }
   }
 
-  execute(
+  override execute(
     server: Server,
-    session: ClientSession,
+    session: ClientSession | undefined,
     callback: Callback<UpdateResult | Document>
   ): void {
     super.execute(server, session, (err, res) => {
@@ -222,6 +232,8 @@ export interface ReplaceOptions extends CommandOperationOptions {
   hint?: string | Document;
   /** When true, creates a new document if no document matches the query */
   upsert?: boolean;
+  /** Map of parameter names and values that can be accessed using $$var (requires MongoDB 5.0). */
+  let?: Document;
 }
 
 /** @internal */
@@ -243,9 +255,9 @@ export class ReplaceOneOperation extends UpdateOperation {
     }
   }
 
-  execute(
+  override execute(
     server: Server,
-    session: ClientSession,
+    session: ClientSession | undefined,
     callback: Callback<UpdateResult | Document>
   ): void {
     super.execute(server, session, (err, res) => {

package/src/operations/validate_collection.ts

@@ -14,7 +14,7 @@ export interface ValidateCollectionOptions extends CommandOperationOptions {
 
 /** @internal */
 export class ValidateCollectionOperation extends CommandOperation<Document> {
-  options: ValidateCollectionOptions;
+  override options: ValidateCollectionOptions;
   collectionName: string;
   command: Document;
 
@@ -34,7 +34,11 @@ export class ValidateCollectionOperation extends CommandOperation<Document> {
     this.collectionName = collectionName;
   }
 
-  execute(server: Server, session: ClientSession, callback: Callback<Document>): void {
+  override execute(
+    server: Server,
+    session: ClientSession | undefined,
+    callback: Callback<Document>
+  ): void {
     const collectionName = this.collectionName;
 
     super.executeCommand(server, session, this.command, (err, doc) => {

package/src/read_concern.ts

@@ -63,6 +63,7 @@ export class ReadConcern {
     if (options.level) {
       return new ReadConcern(options.level);
     }
+    return;
   }
 
   static get MAJORITY(): 'majority' {

package/src/sdam/common.ts

@@ -53,12 +53,6 @@ export function drainTimerQueue(queue: TimerQueue): void {
   queue.clear();
 }
 
-/** @internal */
-export function clearAndRemoveTimerFrom(timer: NodeJS.Timeout, timers: TimerQueue): boolean {
-  clearTimeout(timer);
-  return timers.delete(timer);
-}
-
 /** @public */
 export interface ClusterTime {
   clusterTime: Timestamp;

package/src/sdam/events.ts

@@ -153,10 +153,10 @@ export class ServerHeartbeatSucceededEvent {
   reply: Document;
 
   /** @internal */
-  constructor(connectionId: string, duration: number, reply: Document) {
+  constructor(connectionId: string, duration: number, reply: Document | null) {
     this.connectionId = connectionId;
     this.duration = duration;
-    this.reply = reply;
+    this.reply = reply ?? {};
   }
 }
 

package/src/sdam/monitor.ts

@@ -2,7 +2,7 @@ import { Document, Long } from '../bson';
 import { connect } from '../cmap/connect';
 import { Connection, ConnectionOptions } from '../cmap/connection';
 import { LEGACY_HELLO_COMMAND } from '../constants';
-import { AnyError, MongoNetworkError } from '../error';
+import { MongoNetworkError } from '../error';
 import { CancellationToken, TypedEventEmitter } from '../mongo_types';
 import type { Callback, InterruptibleAsyncInterval } from '../utils';
 import {
@@ -207,11 +207,11 @@ function resetMonitorState(monitor: Monitor) {
   monitor[kConnection] = undefined;
 }
 
-function checkServer(monitor: Monitor, callback: Callback<Document>) {
+function checkServer(monitor: Monitor, callback: Callback<Document | null>) {
   let start = now();
   monitor.emit(Server.SERVER_HEARTBEAT_STARTED, new ServerHeartbeatStartedEvent(monitor.address));
 
-  function failureHandler(err: AnyError) {
+  function failureHandler(err: Error) {
     monitor[kConnection]?.destroy({ force: true });
     monitor[kConnection] = undefined;
 
@@ -259,8 +259,7 @@ function checkServer(monitor: Monitor, callback: Callback<Document>) {
 
     connection.command(ns('admin.$cmd'), cmd, options, (err, hello) => {
       if (err) {
-        failureHandler(err);
-        return;
+        return failureHandler(err);
       }
 
       if (!('isWritablePrimary' in hello)) {

package/src/sdam/server.ts

@@ -27,14 +27,16 @@ import type { AutoEncrypter } from '../deps';
 import {
   isNetworkErrorBeforeHandshake,
   isNodeShuttingDownError,
-  isRetryableWriteError,
   isSDAMUnrecoverableError,
   MongoCompatibilityError,
   MongoError,
+  MongoErrorLabel,
   MongoInvalidArgumentError,
   MongoNetworkError,
   MongoNetworkTimeoutError,
-  MongoServerClosedError
+  MongoServerClosedError,
+  MongoUnexpectedServerResponseError,
+  needsRetryableWriteLabel
 } from '../error';
 import { Logger } from '../logger';
 import type { ServerApi } from '../mongo_client';
@@ -43,7 +45,6 @@ import type { ClientSession } from '../sessions';
 import { isTransactionCommand } from '../transactions';
 import {
   Callback,
-  CallbackWithType,
   collationNotSupported,
   EventEmitterWithState,
   makeStateMachine,
@@ -119,7 +120,7 @@ export class Server extends TypedEventEmitter<ServerEvents> {
   s: ServerPrivate;
   serverApi?: ServerApi;
   hello?: Document;
-  [kMonitor]: Monitor;
+  [kMonitor]: Monitor | null;
 
   /** @event */
   static readonly SERVER_HEARTBEAT_STARTED = SERVER_HEARTBEAT_STARTED;
@@ -163,22 +164,27 @@ export class Server extends TypedEventEmitter<ServerEvents> {
       this.clusterTime = clusterTime;
     });
 
-    // monitoring is disabled in load balancing mode
-    if (this.loadBalanced) return;
+    if (this.loadBalanced) {
+      this[kMonitor] = null;
+      // monitoring is disabled in load balancing mode
+      return;
+    }
 
     // create the monitor
-    this[kMonitor] = new Monitor(this, this.s.options);
+    // TODO(NODE-4144): Remove new variable for type narrowing
+    const monitor = new Monitor(this, this.s.options);
+    this[kMonitor] = monitor;
 
     for (const event of HEARTBEAT_EVENTS) {
-      this[kMonitor].on(event, (e: any) => this.emit(event, e));
+      monitor.on(event, (e: any) => this.emit(event, e));
     }
 
-    this[kMonitor].on('resetConnectionPool', () => {
+    monitor.on('resetConnectionPool', () => {
       this.s.pool.clear();
     });
 
-    this[kMonitor].on('resetServer', (error: MongoError) => markServerUnknown(this, error));
-    this[kMonitor].on(Server.SERVER_HEARTBEAT_SUCCEEDED, (event: ServerHeartbeatSucceededEvent) => {
+    monitor.on('resetServer', (error: MongoError) => markServerUnknown(this, error));
+    monitor.on(Server.SERVER_HEARTBEAT_SUCCEEDED, (event: ServerHeartbeatSucceededEvent) => {
       this.emit(
         Server.DESCRIPTION_RECEIVED,
         new ServerDescription(this.description.hostAddress, event.reply, {
@@ -213,6 +219,7 @@ export class Server extends TypedEventEmitter<ServerEvents> {
     if (this.s.options && this.s.options.autoEncrypter) {
       return this.s.options.autoEncrypter;
     }
+    return;
   }
 
   get loadBalanced(): boolean {
@@ -233,7 +240,7 @@ export class Server extends TypedEventEmitter<ServerEvents> {
     // a load balancer. It never transitions out of this state and
     // has no monitor.
     if (!this.loadBalanced) {
-      this[kMonitor].connect();
+      this[kMonitor]?.connect();
     } else {
       stateTransition(this, STATE_CONNECTED);
       this.emit(Server.CONNECT, this);
@@ -256,7 +263,7 @@ export class Server extends TypedEventEmitter<ServerEvents> {
     stateTransition(this, STATE_CLOSING);
 
     if (!this.loadBalanced) {
-      this[kMonitor].close();
+      this[kMonitor]?.close();
     }
 
     this.s.pool.close(options, err => {
@@ -274,7 +281,7 @@ export class Server extends TypedEventEmitter<ServerEvents> {
    */
   requestCheck(): void {
     if (!this.loadBalanced) {
-      this[kMonitor].requestCheck();
+      this[kMonitor]?.requestCheck();
     }
   }
 
@@ -282,24 +289,12 @@ export class Server extends TypedEventEmitter<ServerEvents> {
    * Execute a command
    * @internal
    */
-  command(ns: MongoDBNamespace, cmd: Document, callback: Callback): void;
-  /** @internal */
   command(
     ns: MongoDBNamespace,
     cmd: Document,
     options: CommandOptions,
     callback: Callback<Document>
-  ): void;
-  command(
-    ns: MongoDBNamespace,
-    cmd: Document,
-    options?: CommandOptions | Callback<Document>,
-    callback?: Callback<Document>
   ): void {
-    if (typeof options === 'function') {
-      (callback = options), (options = {}), (options = options ?? {});
-    }
-
     if (callback == null) {
       throw new MongoInvalidArgumentError('Callback must be provided');
     }
@@ -344,7 +339,7 @@ export class Server extends TypedEventEmitter<ServerEvents> {
         }
 
         session.pin(checkedOut);
-        this.command(ns, cmd, finalOptions, callback as Callback<Document>);
+        this.command(ns, cmd, finalOptions, callback);
       });
 
       return;
@@ -362,7 +357,7 @@ export class Server extends TypedEventEmitter<ServerEvents> {
           ns,
           cmd,
           finalOptions,
-          makeOperationHandler(this, conn, cmd, finalOptions, cb) as Callback<Document>
+          makeOperationHandler(this, conn, cmd, finalOptions, cb)
         );
       },
       callback
@@ -387,12 +382,7 @@ export class Server extends TypedEventEmitter<ServerEvents> {
           return cb(err);
         }
 
-        conn.query(
-          ns,
-          cmd,
-          options,
-          makeOperationHandler(this, conn, cmd, options, cb) as Callback
-        );
+        conn.query(ns, cmd, options, makeOperationHandler(this, conn, cmd, options, cb));
       },
       callback
     );
@@ -421,12 +411,7 @@ export class Server extends TypedEventEmitter<ServerEvents> {
           return cb(err);
         }
 
-        conn.getMore(
-          ns,
-          cursorId,
-          options,
-          makeOperationHandler(this, conn, {}, options, cb) as Callback
-        );
+        conn.getMore(ns, cursorId, options, makeOperationHandler(this, conn, {}, options, cb));
       },
       callback
     );
@@ -462,7 +447,7 @@ export class Server extends TypedEventEmitter<ServerEvents> {
           ns,
           cursorIds,
           options,
-          makeOperationHandler(this, conn, {}, undefined, cb) as Callback
+          makeOperationHandler(this, conn, {}, undefined, cb)
         );
       },
       callback
@@ -486,7 +471,7 @@ function markServerUnknown(server: Server, error?: MongoError) {
   }
 
   if (error instanceof MongoNetworkError && !(error instanceof MongoNetworkTimeoutError)) {
-    server[kMonitor].reset();
+    server[kMonitor]?.reset();
   }
 
   server.emit(
@@ -546,67 +531,87 @@ function makeOperationHandler(
   cmd: Document,
   options: CommandOptions | GetMoreOptions | undefined,
   callback: Callback
-): CallbackWithType<MongoError, Document> {
+): Callback {
   const session = options?.session;
-  return function handleOperationResult(err, result) {
-    if (err && !connectionIsStale(server.s.pool, connection)) {
-      if (err instanceof MongoNetworkError) {
-        if (session && !session.hasEnded && session.serverSession) {
-          session.serverSession.isDirty = true;
-        }
+  return function handleOperationResult(error, result) {
+    if (result != null) {
+      return callback(undefined, result);
+    }
 
-        // inActiveTransaction check handles commit and abort.
-        if (inActiveTransaction(session, cmd) && !err.hasErrorLabel('TransientTransactionError')) {
-          err.addErrorLabel('TransientTransactionError');
-        }
+    if (!error) {
+      return callback(new MongoUnexpectedServerResponseError('Empty response with no error'));
+    }
 
-        if (
-          (isRetryableWritesEnabled(server.s.topology) || isTransactionCommand(cmd)) &&
-          supportsRetryableWrites(server) &&
-          !inActiveTransaction(session, cmd)
-        ) {
-          err.addErrorLabel('RetryableWriteError');
-        }
+    if (!(error instanceof MongoError)) {
+      // Node.js or some other error we have not special handling for
+      return callback(error);
+    }
 
-        if (!(err instanceof MongoNetworkTimeoutError) || isNetworkErrorBeforeHandshake(err)) {
-          // In load balanced mode we never mark the server as unknown and always
-          // clear for the specific service id.
+    if (connectionIsStale(server.s.pool, connection)) {
+      return callback(error);
+    }
 
-          server.s.pool.clear(connection.serviceId);
-          if (!server.loadBalanced) {
-            markServerUnknown(server, err);
-          }
-        }
-      } else {
-        // if pre-4.4 server, then add error label if its a retryable write error
-        if (
-          (isRetryableWritesEnabled(server.s.topology) || isTransactionCommand(cmd)) &&
-          maxWireVersion(server) < 9 &&
-          isRetryableWriteError(err) &&
-          !inActiveTransaction(session, cmd)
-        ) {
-          err.addErrorLabel('RetryableWriteError');
+    if (error instanceof MongoNetworkError) {
+      if (session && !session.hasEnded && session.serverSession) {
+        session.serverSession.isDirty = true;
+      }
+
+      // inActiveTransaction check handles commit and abort.
+      if (
+        inActiveTransaction(session, cmd) &&
+        !error.hasErrorLabel(MongoErrorLabel.TransientTransactionError)
+      ) {
+        error.addErrorLabel(MongoErrorLabel.TransientTransactionError);
+      }
+
+      if (
+        (isRetryableWritesEnabled(server.s.topology) || isTransactionCommand(cmd)) &&
+        supportsRetryableWrites(server) &&
+        !inActiveTransaction(session, cmd)
+      ) {
+        error.addErrorLabel(MongoErrorLabel.RetryableWriteError);
+      }
+
+      if (!(error instanceof MongoNetworkTimeoutError) || isNetworkErrorBeforeHandshake(error)) {
+        // In load balanced mode we never mark the server as unknown and always
+        // clear for the specific service id.
+
+        server.s.pool.clear(connection.serviceId);
+        if (!server.loadBalanced) {
+          markServerUnknown(server, error);
         }
+      }
+    } else {
+      if (
+        (isRetryableWritesEnabled(server.s.topology) || isTransactionCommand(cmd)) &&
+        needsRetryableWriteLabel(error, maxWireVersion(server)) &&
+        !inActiveTransaction(session, cmd)
+      ) {
+        error.addErrorLabel(MongoErrorLabel.RetryableWriteError);
+      }
 
-        if (isSDAMUnrecoverableError(err)) {
-          if (shouldHandleStateChangeError(server, err)) {
-            if (maxWireVersion(server) <= 7 || isNodeShuttingDownError(err)) {
-              server.s.pool.clear(connection.serviceId);
-            }
+      if (isSDAMUnrecoverableError(error)) {
+        if (shouldHandleStateChangeError(server, error)) {
+          if (maxWireVersion(server) <= 7 || isNodeShuttingDownError(error)) {
+            server.s.pool.clear(connection.serviceId);
+          }
 
-            if (!server.loadBalanced) {
-              markServerUnknown(server, err);
-              process.nextTick(() => server.requestCheck());
-            }
+          if (!server.loadBalanced) {
+            markServerUnknown(server, error);
+            process.nextTick(() => server.requestCheck());
           }
         }
       }
+    }
 
-      if (session && session.isPinned && err.hasErrorLabel('TransientTransactionError')) {
-        session.unpin({ force: true });
-      }
+    if (
+      session &&
+      session.isPinned &&
+      error.hasErrorLabel(MongoErrorLabel.TransientTransactionError)
+    ) {
+      session.unpin({ force: true });
     }
 
-    callback(err, result);
+    return callback(error);
   };
 }