mongodb 6.12.0-dev.20250125.sha.c1bcf0de → 6.12.0-dev.20250128.sha.654069fc

package/src/sdam/server.ts

@@ -36,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,
@@ -107,7 +108,7 @@ export type ServerEvents = {
 /** @internal */
 export type ServerCommandOptions = Omit<CommandOptions, 'timeoutContext' | 'socketTimeoutMS'> & {
   timeoutContext: TimeoutContext;
-};
+} & Abortable;
 
 /** @internal */
 export class Server extends TypedEventEmitter<ServerEvents> {
@@ -285,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') {
@@ -296,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();
@@ -331,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;
@@ -358,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);
+        }
       }
     }
   }

package/src/sdam/topology.ts

@@ -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,
@@ -525,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') {
@@ -602,6 +604,11 @@ export class Topology extends TypedEventEmitter<TopologyEvents> {
       previousServer: options.previousServer
     };
 
+    const abortListener = addAbortListener(options.signal, function () {
+      waitQueueMember.cancelled = true;
+      reject(this.reason);
+    });
+
     this.waitQueue.push(waitQueueMember);
     processWaitQueue(this);
 
@@ -647,6 +654,7 @@ export class Topology extends TypedEventEmitter<TopologyEvents> {
       // Other server selection error
       throw error;
     } finally {
+      abortListener?.[kDispose]();
       if (options.timeoutContext?.clearServerSelectionTimeout) timeout?.clear();
     }
   }

package/src/utils.ts

@@ -27,6 +27,7 @@ import {
   MongoRuntimeError
 } from './error';
 import type { MongoClient } from './mongo_client';
+import { type Abortable } from './mongo_types';
 import type { CommandOperationOptions, OperationParent } from './operations/command';
 import type { Hint, OperationOptions } from './operations/operation';
 import { ReadConcern } from './read_concern';
@@ -1312,19 +1313,24 @@ export const randomBytes = promisify(crypto.randomBytes);
  * @param ee - An event emitter that may emit `ev`
  * @param name - An event name to wait for
  */
-export async function once<T>(ee: EventEmitter, name: string): Promise<T> {
+export async function once<T>(ee: EventEmitter, name: string, options?: Abortable): Promise<T> {
+  options?.signal?.throwIfAborted();
+
   const { promise, resolve, reject } = promiseWithResolvers<T>();
   const onEvent = (data: T) => resolve(data);
   const onError = (error: Error) => reject(error);
+  const abortListener = addAbortListener(options?.signal, function () {
+    reject(this.reason);
+  });
 
   ee.once(name, onEvent).once('error', onError);
+
   try {
-    const res = await promise;
-    ee.off('error', onError);
-    return res;
-  } catch (error) {
+    return await promise;
+  } finally {
     ee.off(name, onEvent);
-    throw error;
+    ee.off('error', onError);
+    abortListener?.[kDispose]();
   }
 }
 
@@ -1431,3 +1437,70 @@ export function decorateDecryptionResult(
     decorateDecryptionResult(decrypted[k], originalValue, false);
   }
 }
+
+/** @internal */
+export const kDispose: unique symbol = (Symbol.dispose as any) ?? Symbol('dispose');
+
+/** @internal */
+export interface Disposable {
+  [kDispose](): void;
+}
+
+/**
+ * A utility that helps with writing listener code idiomatically
+ *
+ * @example
+ * ```js
+ * using listener = addAbortListener(signal, function () {
+ *   console.log('aborted', this.reason);
+ * });
+ * ```
+ *
+ * @param signal - if exists adds an abort listener
+ * @param listener - the listener to be added to signal
+ * @returns A disposable that will remove the abort listener
+ */
+export function addAbortListener(
+  signal: AbortSignal | undefined | null,
+  listener: (this: AbortSignal, event: Event) => void
+): Disposable | undefined {
+  if (signal == null) return;
+  signal.addEventListener('abort', listener, { once: true });
+  return { [kDispose]: () => signal.removeEventListener('abort', listener) };
+}
+
+/**
+ * Takes a promise and races it with a promise wrapping the abort event of the optionally provided signal.
+ * The given promise is _always_ ordered before the signal's abort promise.
+ * When given an already rejected promise and an already aborted signal, the promise's rejection takes precedence.
+ *
+ * Any asynchronous processing in `promise` will continue even after the abort signal has fired,
+ * but control will be returned to the caller
+ *
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise/race
+ *
+ * @param promise - A promise to discard if the signal aborts
+ * @param options - An options object carrying an optional signal
+ */
+export async function abortable<T>(
+  promise: Promise<T>,
+  { signal }: { signal?: AbortSignal }
+): Promise<T> {
+  if (signal == null) {
+    return await promise;
+  }
+
+  const { promise: aborted, reject } = promiseWithResolvers<never>();
+
+  const abortListener = signal.aborted
+    ? reject(signal.reason)
+    : addAbortListener(signal, function () {
+        reject(this.reason);
+      });
+
+  try {
+    return await Promise.race([promise, aborted]);
+  } finally {
+    abortListener?.[kDispose]();
+  }
+}