mongodb 6.12.0 → 6.13.0

package/src/sdam/server.ts

@@ -22,7 +22,6 @@ import {
 } from '../constants';
 import {
   type AnyError,
-  isNetworkErrorBeforeHandshake,
   isNodeShuttingDownError,
   isSDAMUnrecoverableError,
   MONGODB_ERROR_CODES,
@@ -37,12 +36,13 @@ import {
   needsRetryableWriteLabel
 } from '../error';
 import type { ServerApi } from '../mongo_client';
-import { TypedEventEmitter } from '../mongo_types';
+import { type Abortable, TypedEventEmitter } from '../mongo_types';
 import type { GetMoreOptions } from '../operations/get_more';
 import type { ClientSession } from '../sessions';
 import { type TimeoutContext } from '../timeout';
 import { isTransactionCommand } from '../transactions';
 import {
+  abortable,
   type EventEmitterWithState,
   makeStateMachine,
   maxWireVersion,
@@ -108,7 +108,7 @@ export type ServerEvents = {
 /** @internal */
 export type ServerCommandOptions = Omit<CommandOptions, 'timeoutContext' | 'socketTimeoutMS'> & {
   timeoutContext: TimeoutContext;
-};
+} & Abortable;
 
 /** @internal */
 export class Server extends TypedEventEmitter<ServerEvents> {
@@ -286,7 +286,7 @@ export class Server extends TypedEventEmitter<ServerEvents> {
   public async command(
     ns: MongoDBNamespace,
     cmd: Document,
-    options: ServerCommandOptions,
+    { ...options }: ServerCommandOptions,
     responseType?: MongoDBResponseConstructor
   ): Promise<Document> {
     if (ns.db == null || typeof ns === 'string') {
@@ -297,25 +297,21 @@ export class Server extends TypedEventEmitter<ServerEvents> {
       throw new MongoServerClosedError();
     }
 
-    // Clone the options
-    const finalOptions = Object.assign({}, options, {
-      wireProtocolCommand: false,
-      directConnection: this.topology.s.options.directConnection
-    });
+    options.directConnection = this.topology.s.options.directConnection;
 
     // There are cases where we need to flag the read preference not to get sent in
     // the command, such as pre-5.0 servers attempting to perform an aggregate write
     // with a non-primary read preference. In this case the effective read preference
     // (primary) is not the same as the provided and must be removed completely.
-    if (finalOptions.omitReadPreference) {
-      delete finalOptions.readPreference;
+    if (options.omitReadPreference) {
+      delete options.readPreference;
     }
 
     if (this.description.iscryptd) {
-      finalOptions.omitMaxTimeMS = true;
+      options.omitMaxTimeMS = true;
     }
 
-    const session = finalOptions.session;
+    const session = options.session;
     let conn = session?.pinnedConnection;
 
     this.incrementOperationCount();
@@ -332,26 +328,35 @@ export class Server extends TypedEventEmitter<ServerEvents> {
       }
     }
 
+    let reauthPromise: Promise<void> | null = null;
+
     try {
       try {
-        const res = await conn.command(ns, cmd, finalOptions, responseType);
+        const res = await conn.command(ns, cmd, options, responseType);
         throwIfWriteConcernError(res);
         return res;
       } catch (commandError) {
-        throw this.decorateCommandError(conn, cmd, finalOptions, commandError);
+        throw this.decorateCommandError(conn, cmd, options, commandError);
       }
     } catch (operationError) {
       if (
         operationError instanceof MongoError &&
         operationError.code === MONGODB_ERROR_CODES.Reauthenticate
       ) {
-        await this.pool.reauthenticate(conn);
+        reauthPromise = this.pool.reauthenticate(conn).catch(error => {
+          reauthPromise = null;
+          throw error;
+        });
+
+        await abortable(reauthPromise, options);
+        reauthPromise = null; // only reachable if reauth succeeds
+
         try {
-          const res = await conn.command(ns, cmd, finalOptions, responseType);
+          const res = await conn.command(ns, cmd, options, responseType);
           throwIfWriteConcernError(res);
           return res;
         } catch (commandError) {
-          throw this.decorateCommandError(conn, cmd, finalOptions, commandError);
+          throw this.decorateCommandError(conn, cmd, options, commandError);
         }
       } else {
         throw operationError;
@@ -359,7 +364,14 @@ export class Server extends TypedEventEmitter<ServerEvents> {
     } finally {
       this.decrementOperationCount();
       if (session?.pinnedConnection !== conn) {
-        this.pool.checkIn(conn);
+        if (reauthPromise != null) {
+          // The reauth promise only exists if it hasn't thrown.
+          void reauthPromise.finally(() => {
+            this.pool.checkIn(conn);
+          });
+        } else {
+          this.pool.checkIn(conn);
+        }
       }
     }
   }
@@ -381,7 +393,8 @@ export class Server extends TypedEventEmitter<ServerEvents> {
 
     const isNetworkNonTimeoutError =
       error instanceof MongoNetworkError && !(error instanceof MongoNetworkTimeoutError);
-    const isNetworkTimeoutBeforeHandshakeError = isNetworkErrorBeforeHandshake(error);
+    const isNetworkTimeoutBeforeHandshakeError =
+      error instanceof MongoNetworkError && error.beforeHandshake;
     const isAuthHandshakeError = error.hasErrorLabel(MongoErrorLabel.HandshakeError);
     if (isNetworkNonTimeoutError || isNetworkTimeoutBeforeHandshakeError || isAuthHandshakeError) {
       // In load balanced mode we never mark the server as unknown and always

package/src/sdam/topology.ts

@@ -3,7 +3,7 @@ import type { MongoCredentials } from '../cmap/auth/mongo_credentials';
 import type { ConnectionEvents } from '../cmap/connection';
 import type { ConnectionPoolEvents } from '../cmap/connection_pool';
 import type { ClientMetadata } from '../cmap/handshake/client_metadata';
-import { DEFAULT_OPTIONS, FEATURE_FLAGS } from '../connection_string';
+import { DEFAULT_OPTIONS } from '../connection_string';
 import {
   CLOSE,
   CONNECT,
@@ -31,15 +31,17 @@ import {
 } from '../error';
 import type { MongoClient, ServerApi } from '../mongo_client';
 import { MongoLoggableComponent, type MongoLogger, SeverityLevel } from '../mongo_logger';
-import { TypedEventEmitter } from '../mongo_types';
+import { type Abortable, TypedEventEmitter } from '../mongo_types';
 import { ReadPreference, type ReadPreferenceLike } from '../read_preference';
 import type { ClientSession } from '../sessions';
 import { Timeout, TimeoutContext, TimeoutError } from '../timeout';
 import type { Transaction } from '../transactions';
 import {
+  addAbortListener,
   type Callback,
   type EventEmitterWithState,
   HostAddress,
+  kDispose,
   List,
   makeStateMachine,
   now,
@@ -88,11 +90,6 @@ const stateTransition = makeStateMachine({
   [STATE_CLOSING]: [STATE_CLOSING, STATE_CLOSED]
 });
 
-/** @internal */
-const kCancelled = Symbol('cancelled');
-/** @internal */
-const kWaitQueue = Symbol('waitQueue');
-
 /** @internal */
 export type ServerSelectionCallback = Callback<Server>;
 
@@ -105,7 +102,7 @@ export interface ServerSelectionRequest {
   startTime: number;
   resolve: (server: Server) => void;
   reject: (error: MongoError) => void;
-  [kCancelled]?: boolean;
+  cancelled: boolean;
   operationName: string;
   waitingLogged: boolean;
   previousServer?: ServerDescription;
@@ -158,7 +155,7 @@ export interface TopologyOptions extends BSONSerializeOptions, ServerOptions {
   serverMonitoringMode: ServerMonitoringMode;
   /** MongoDB server API version */
   serverApi?: ServerApi;
-  [featureFlag: symbol]: any;
+  __skipPingOnConnect?: boolean;
 }
 
 /** @public */
@@ -208,7 +205,7 @@ export class Topology extends TypedEventEmitter<TopologyEvents> {
   /** @internal */
   s: TopologyPrivate;
   /** @internal */
-  [kWaitQueue]: List<ServerSelectionRequest>;
+  waitQueue: List<ServerSelectionRequest>;
   /** @internal */
   hello?: Document;
   /** @internal */
@@ -256,8 +253,7 @@ export class Topology extends TypedEventEmitter<TopologyEvents> {
     // Options should only be undefined in tests, MongoClient will always have defined options
     options = options ?? {
       hosts: [HostAddress.fromString('localhost:27017')],
-      ...Object.fromEntries(DEFAULT_OPTIONS.entries()),
-      ...Object.fromEntries(FEATURE_FLAGS.entries())
+      ...Object.fromEntries(DEFAULT_OPTIONS.entries())
     };
 
     if (typeof seeds === 'string') {
@@ -293,7 +289,7 @@ export class Topology extends TypedEventEmitter<TopologyEvents> {
       serverDescriptions.set(hostAddress.toString(), new ServerDescription(hostAddress));
     }
 
-    this[kWaitQueue] = new List();
+    this.waitQueue = new List();
     this.s = {
       // the id of this topology
       id: topologyId,
@@ -471,7 +467,7 @@ export class Topology extends TypedEventEmitter<TopologyEvents> {
         readPreferenceServerSelector(readPreference),
         selectServerOptions
       );
-      const skipPingOnConnect = this.s.options[Symbol.for('@@mdb.skipPingOnConnect')] === true;
+      const skipPingOnConnect = this.s.options.__skipPingOnConnect === true;
       if (!skipPingOnConnect && this.s.credentials) {
         await server.command(ns('admin.$cmd'), { ping: 1 }, { timeoutContext });
         stateTransition(this, STATE_CONNECTED);
@@ -506,7 +502,7 @@ export class Topology extends TypedEventEmitter<TopologyEvents> {
 
     stateTransition(this, STATE_CLOSING);
 
-    drainWaitQueue(this[kWaitQueue], new MongoTopologyClosedError());
+    drainWaitQueue(this.waitQueue, new MongoTopologyClosedError());
 
     if (this.s.srvPoller) {
       this.s.srvPoller.stop();
@@ -531,7 +527,7 @@ export class Topology extends TypedEventEmitter<TopologyEvents> {
    */
   async selectServer(
     selector: string | ReadPreference | ServerSelector,
-    options: SelectServerOptions
+    options: SelectServerOptions & Abortable
   ): Promise<Server> {
     let serverSelector;
     if (typeof selector !== 'function') {
@@ -601,13 +597,19 @@ export class Topology extends TypedEventEmitter<TopologyEvents> {
       transaction,
       resolve,
       reject,
+      cancelled: false,
       startTime: now(),
       operationName: options.operationName,
       waitingLogged: false,
       previousServer: options.previousServer
     };
 
-    this[kWaitQueue].push(waitQueueMember);
+    const abortListener = addAbortListener(options.signal, function () {
+      waitQueueMember.cancelled = true;
+      reject(this.reason);
+    });
+
+    this.waitQueue.push(waitQueueMember);
     processWaitQueue(this);
 
     try {
@@ -620,7 +622,7 @@ export class Topology extends TypedEventEmitter<TopologyEvents> {
     } catch (error) {
       if (TimeoutError.is(error)) {
         // Timeout
-        waitQueueMember[kCancelled] = true;
+        waitQueueMember.cancelled = true;
         const timeoutError = new MongoServerSelectionError(
           `Server selection timed out after ${timeout?.duration} ms`,
           this.description
@@ -652,6 +654,7 @@ export class Topology extends TypedEventEmitter<TopologyEvents> {
       // Other server selection error
       throw error;
     } finally {
+      abortListener?.[kDispose]();
       if (options.timeoutContext?.clearServerSelectionTimeout) timeout?.clear();
     }
   }
@@ -721,7 +724,7 @@ export class Topology extends TypedEventEmitter<TopologyEvents> {
     updateServers(this, serverDescription);
 
     // attempt to resolve any outstanding server selection attempts
-    if (this[kWaitQueue].length > 0) {
+    if (this.waitQueue.length > 0) {
       processWaitQueue(this);
     }
 
@@ -910,7 +913,7 @@ function drainWaitQueue(queue: List<ServerSelectionRequest>, drainError: MongoDr
       continue;
     }
 
-    if (!waitQueueMember[kCancelled]) {
+    if (!waitQueueMember.cancelled) {
       if (
         waitQueueMember.mongoLogger?.willLog(
           MongoLoggableComponent.SERVER_SELECTION,
@@ -934,20 +937,20 @@ function drainWaitQueue(queue: List<ServerSelectionRequest>, drainError: MongoDr
 
 function processWaitQueue(topology: Topology) {
   if (topology.s.state === STATE_CLOSED) {
-    drainWaitQueue(topology[kWaitQueue], new MongoTopologyClosedError());
+    drainWaitQueue(topology.waitQueue, new MongoTopologyClosedError());
     return;
   }
 
   const isSharded = topology.description.type === TopologyType.Sharded;
   const serverDescriptions = Array.from(topology.description.servers.values());
-  const membersToProcess = topology[kWaitQueue].length;
+  const membersToProcess = topology.waitQueue.length;
   for (let i = 0; i < membersToProcess; ++i) {
-    const waitQueueMember = topology[kWaitQueue].shift();
+    const waitQueueMember = topology.waitQueue.shift();
     if (!waitQueueMember) {
       continue;
     }
 
-    if (waitQueueMember[kCancelled]) {
+    if (waitQueueMember.cancelled) {
       continue;
     }
 
@@ -1006,7 +1009,7 @@ function processWaitQueue(topology: Topology) {
         }
         waitQueueMember.waitingLogged = true;
       }
-      topology[kWaitQueue].push(waitQueueMember);
+      topology.waitQueue.push(waitQueueMember);
       continue;
     } else if (selectedDescriptions.length === 1) {
       selectedServer = topology.s.servers.get(selectedDescriptions[0].address);
@@ -1069,7 +1072,7 @@ function processWaitQueue(topology: Topology) {
     waitQueueMember.resolve(selectedServer);
   }
 
-  if (topology[kWaitQueue].length > 0) {
+  if (topology.waitQueue.length > 0) {
     // ensure all server monitors attempt monitoring soon
     for (const [, server] of topology.s.servers) {
       process.nextTick(function scheduleServerCheck() {

package/src/sessions.ts

@@ -83,17 +83,6 @@ export type ClientSessionEvents = {
   ended(session: ClientSession): void;
 };
 
-/** @internal */
-const kServerSession = Symbol('serverSession');
-/** @internal */
-const kSnapshotTime = Symbol('snapshotTime');
-/** @internal */
-const kSnapshotEnabled = Symbol('snapshotEnabled');
-/** @internal */
-const kPinnedConnection = Symbol('pinnedConnection');
-/** @internal Accumulates total number of increments to add to txnNumber when applying session to command */
-const kTxnNumberIncrement = Symbol('txnNumberIncrement');
-
 /** @public */
 export interface EndSessionOptions {
   /**
@@ -132,20 +121,22 @@ export class ClientSession
   owner?: symbol | AbstractCursor;
   defaultTransactionOptions: TransactionOptions;
   transaction: Transaction;
-  /** @internal
+  /**
+   * @internal
    * Keeps track of whether or not the current transaction has attempted to be committed. Is
-   * initially undefined. Gets set to false when startTransaction is called. When commitTransaction is sent to server, if the commitTransaction succeeds, it is then set to undefined, otherwise, set to true */
-  commitAttempted?: boolean;
-  /** @internal */
-  private [kServerSession]: ServerSession | null;
+   * initially undefined. Gets set to false when startTransaction is called. When commitTransaction is sent to server, if the commitTransaction succeeds, it is then set to undefined, otherwise, set to true
+   */
+  private commitAttempted?: boolean;
+  public readonly snapshotEnabled: boolean;
+
   /** @internal */
-  [kSnapshotTime]?: Timestamp;
+  private _serverSession: ServerSession | null;
   /** @internal */
-  [kSnapshotEnabled] = false;
+  public snapshotTime?: Timestamp;
   /** @internal */
-  [kPinnedConnection]?: Connection;
+  public pinnedConnection?: Connection;
   /** @internal */
-  [kTxnNumberIncrement]: number;
+  public txnNumberIncrement: number;
   /**
    * @experimental
    * Specifies the time an operation in a given `ClientSession` will run until it throws a timeout error
@@ -183,13 +174,11 @@ export class ClientSession
 
     options = options ?? {};
 
-    if (options.snapshot === true) {
-      this[kSnapshotEnabled] = true;
-      if (options.causalConsistency === true) {
-        throw new MongoInvalidArgumentError(
-          'Properties "causalConsistency" and "snapshot" are mutually exclusive'
-        );
-      }
+    this.snapshotEnabled = options.snapshot === true;
+    if (options.causalConsistency === true && this.snapshotEnabled) {
+      throw new MongoInvalidArgumentError(
+        'Properties "causalConsistency" and "snapshot" are mutually exclusive'
+      );
     }
 
     this.client = client;
@@ -199,8 +188,8 @@ export class ClientSession
     this.timeoutMS = options.defaultTimeoutMS ?? client.s.options?.timeoutMS;
 
     this.explicit = !!options.explicit;
-    this[kServerSession] = this.explicit ? this.sessionPool.acquire() : null;
-    this[kTxnNumberIncrement] = 0;
+    this._serverSession = this.explicit ? this.sessionPool.acquire() : null;
+    this.txnNumberIncrement = 0;
 
     const defaultCausalConsistencyValue = this.explicit && options.snapshot !== true;
     this.supports = {
@@ -218,11 +207,11 @@ export class ClientSession
 
   /** The server id associated with this session */
   get id(): ServerSessionId | undefined {
-    return this[kServerSession]?.id;
+    return this.serverSession?.id;
   }
 
   get serverSession(): ServerSession {
-    let serverSession = this[kServerSession];
+    let serverSession = this._serverSession;
     if (serverSession == null) {
       if (this.explicit) {
         throw new MongoRuntimeError('Unexpected null serverSession for an explicit session');
@@ -231,32 +220,22 @@ export class ClientSession
         throw new MongoRuntimeError('Unexpected null serverSession for an ended implicit session');
       }
       serverSession = this.sessionPool.acquire();
-      this[kServerSession] = serverSession;
+      this._serverSession = serverSession;
     }
     return serverSession;
   }
 
-  /** Whether or not this session is configured for snapshot reads */
-  get snapshotEnabled(): boolean {
-    return this[kSnapshotEnabled];
-  }
-
   get loadBalanced(): boolean {
     return this.client.topology?.description.type === TopologyType.LoadBalanced;
   }
 
-  /** @internal */
-  get pinnedConnection(): Connection | undefined {
-    return this[kPinnedConnection];
-  }
-
   /** @internal */
   pin(conn: Connection): void {
-    if (this[kPinnedConnection]) {
+    if (this.pinnedConnection) {
       throw TypeError('Cannot pin multiple connections to the same session');
     }
 
-    this[kPinnedConnection] = conn;
+    this.pinnedConnection = conn;
     conn.emit(
       PINNED,
       this.inTransaction() ? ConnectionPoolMetrics.TXN : ConnectionPoolMetrics.CURSOR
@@ -273,7 +252,7 @@ export class ClientSession
   }
 
   get isPinned(): boolean {
-    return this.loadBalanced ? !!this[kPinnedConnection] : this.transaction.isPinned;
+    return this.loadBalanced ? !!this.pinnedConnection : this.transaction.isPinned;
   }
 
   /**
@@ -295,12 +274,12 @@ export class ClientSession
       squashError(error);
     } finally {
       if (!this.hasEnded) {
-        const serverSession = this[kServerSession];
+        const serverSession = this.serverSession;
         if (serverSession != null) {
           // release the server session back to the pool
           this.sessionPool.release(serverSession);
           // Store a clone of the server session for reference (debugging)
-          this[kServerSession] = new ServerSession(serverSession);
+          this._serverSession = new ServerSession(serverSession);
         }
         // mark the session as ended, and emit a signal
         this.hasEnded = true;
@@ -391,7 +370,7 @@ export class ClientSession
    * This is because the serverSession is lazily acquired after a connection is obtained
    */
   incrementTransactionNumber(): void {
-    this[kTxnNumberIncrement] += 1;
+    this.txnNumberIncrement += 1;
   }
 
   /** @returns whether this session is currently in a transaction or not */
@@ -410,7 +389,7 @@ export class ClientSession
    * @param options - Options for the transaction
    */
   startTransaction(options?: TransactionOptions): void {
-    if (this[kSnapshotEnabled]) {
+    if (this.snapshotEnabled) {
       throw new MongoCompatibilityError('Transactions are not supported in snapshot sessions');
     }
 
@@ -908,7 +887,7 @@ export function maybeClearPinnedConnection(
   options?: EndSessionOptions
 ): void {
   // unpin a connection if it has been pinned
-  const conn = session[kPinnedConnection];
+  const conn = session.pinnedConnection;
   const error = options?.error;
 
   if (
@@ -929,7 +908,7 @@ export function maybeClearPinnedConnection(
 
     if (options?.error == null || options?.force) {
       loadBalancer.pool.checkIn(conn);
-      session[kPinnedConnection] = undefined;
+      session.pinnedConnection = undefined;
       conn.emit(
         UNPINNED,
         session.transaction.state !== TxnState.NO_TRANSACTION
@@ -1123,8 +1102,8 @@ export function applySession(
   const isRetryableWrite = !!options.willRetryWrite;
 
   if (isRetryableWrite || inTxnOrTxnCommand) {
-    serverSession.txnNumber += session[kTxnNumberIncrement];
-    session[kTxnNumberIncrement] = 0;
+    serverSession.txnNumber += session.txnNumberIncrement;
+    session.txnNumberIncrement = 0;
     // TODO(NODE-2674): Preserve int64 sent from MongoDB
     command.txnNumber = Long.fromNumber(serverSession.txnNumber);
   }
@@ -1141,10 +1120,10 @@ export function applySession(
     ) {
       command.readConcern = command.readConcern || {};
       Object.assign(command.readConcern, { afterClusterTime: session.operationTime });
-    } else if (session[kSnapshotEnabled]) {
+    } else if (session.snapshotEnabled) {
       command.readConcern = command.readConcern || { level: ReadConcernLevel.snapshot };
-      if (session[kSnapshotTime] != null) {
-        Object.assign(command.readConcern, { atClusterTime: session[kSnapshotTime] });
+      if (session.snapshotTime != null) {
+        Object.assign(command.readConcern, { atClusterTime: session.snapshotTime });
       }
     }
 
@@ -1187,12 +1166,12 @@ export function updateSessionFromResponse(session: ClientSession, document: Mong
     session.transaction._recoveryToken = document.recoveryToken;
   }
 
-  if (session?.[kSnapshotEnabled] && session[kSnapshotTime] == null) {
+  if (session?.snapshotEnabled && session.snapshotTime == null) {
     // find and aggregate commands return atClusterTime on the cursor
     // distinct includes it in the response body
     const atClusterTime = document.atClusterTime;
     if (atClusterTime) {
-      session[kSnapshotTime] = atClusterTime;
+      session.snapshotTime = atClusterTime;
     }
   }
 }