mongodb 7.7.0 → 7.8.0

package/src/sdam/topology.ts

@@ -152,6 +152,8 @@ export interface TopologyOptions extends BSONSerializeOptions, ServerOptions {
   /** The name of the replica set to connect to */
   replicaSet?: string;
   srvHost?: string;
+  srvAllowedHostsSuffix?: string;
+  srvHostValidator?: (host: string) => boolean;
   srvPoller?: SrvPoller;
   /** Indicates that a client should directly connect to a node without attempting to discover its topology type */
   directConnection: boolean;
@@ -334,7 +336,9 @@ export class Topology extends TypedEventEmitter<TopologyEvents> {
           heartbeatFrequencyMS: this.s.heartbeatFrequencyMS,
           srvHost: options.srvHost,
           srvMaxHosts: options.srvMaxHosts,
-          srvServiceName: options.srvServiceName
+          srvServiceName: options.srvServiceName,
+          srvAllowedHostsSuffix: options.srvAllowedHostsSuffix,
+          srvHostValidator: options.srvHostValidator
         });
 
       this.on(Topology.TOPOLOGY_DESCRIPTION_CHANGED, this.s.detectShardedTopology);

package/src/sessions.ts

@@ -30,7 +30,7 @@ import { RunCommandOperation } from './operations/run_command';
 import { ReadConcernLevel } from './read_concern';
 import { ReadPreference } from './read_preference';
 import { _advanceClusterTime, type ClusterTime, TopologyType } from './sdam/common';
-import { TimeoutContext } from './timeout';
+import { type TimeoutContext } from './timeout';
 import {
   isTransactionCommand,
   Transaction,
@@ -60,9 +60,8 @@ export interface ClientSessionOptions {
   defaultTransactionOptions?: TransactionOptions;
   /**
    * @public
-   * @experimental
    * An overriding timeoutMS value to use for a client-side timeout.
-   * If not provided the session uses the timeoutMS specified on the MongoClient.
+   * @deprecated `timeoutMS` has no effect and will be removed in a future release.
    */
   defaultTimeoutMS?: number;
 
@@ -92,7 +91,10 @@ export interface EndSessionOptions {
   force?: boolean;
   forceClear?: boolean;
 
-  /** Specifies the time an operation will run until it throws a timeout error */
+  /**
+   * Specifies the time an operation will run until it throws a timeout error
+   * @deprecated `timeoutMS` has no effect and will be removed in a future release.
+   */
   timeoutMS?: number;
 }
 
@@ -138,8 +140,8 @@ export class ClientSession
   /** @internal */
   public txnNumberIncrement: number;
   /**
-   * @experimental
    * Specifies the time an operation in a given `ClientSession` will run until it throws a timeout error
+   * @deprecated `timeoutMS` has no effect and will be removed in a future release.
    */
   timeoutMS?: number;
 
@@ -186,7 +188,6 @@ export class ClientSession
     this.sessionPool = sessionPool;
     this.hasEnded = false;
     this.clientOptions = clientOptions;
-    this.timeoutMS = options.defaultTimeoutMS ?? client.s.options?.timeoutMS;
 
     this.explicit = !!options.explicit;
     this._serverSession = this.explicit ? this.sessionPool.acquire() : null;
@@ -424,9 +425,12 @@ export class ClientSession
   /**
    * Commits the currently active transaction in this session.
    *
-   * @param options - Optional options, can be used to override `defaultTimeoutMS`.
+   * @param _options - `timeoutMS` is deprecated and has no effect.
    */
-  async commitTransaction(options?: { timeoutMS?: number }): Promise<void> {
+  async commitTransaction(_options?: {
+    /** @deprecated `timeoutMS` has no effect and will be removed in a future release. */
+    timeoutMS?: number;
+  }): Promise<void> {
     if (this.transaction.state === TxnState.NO_TRANSACTION) {
       throw new MongoTransactionError('No transaction started');
     }
@@ -453,16 +457,9 @@ export class ClientSession
       maxTimeMS?: number;
     } = { commitTransaction: 1 };
 
-    const timeoutMS =
-      typeof options?.timeoutMS === 'number'
-        ? options.timeoutMS
-        : typeof this.timeoutMS === 'number'
-          ? this.timeoutMS
-          : null;
-
     const wc = this.transaction.options.writeConcern ?? this.clientOptions?.writeConcern;
     if (wc != null) {
-      if (timeoutMS == null && this.timeoutContext == null) {
+      if (this.timeoutContext == null) {
         WriteConcern.apply(command, { wtimeoutMS: 10000, w: 'majority', ...wc });
       } else {
         const wcKeys = Object.keys(wc);
@@ -477,7 +474,7 @@ export class ClientSession
     }
 
     if (this.transaction.state === TxnState.TRANSACTION_COMMITTED || this.commitAttempted) {
-      if (timeoutMS == null && this.timeoutContext == null) {
+      if (this.timeoutContext == null) {
         WriteConcern.apply(command, { wtimeoutMS: 10000, ...wc, w: 'majority' });
       } else {
         WriteConcern.apply(command, { w: 'majority', ...wc, wtimeoutMS: undefined });
@@ -499,18 +496,8 @@ export class ClientSession
     });
     operation.maxAttempts = this.clientOptions.maxAdaptiveRetries + 1;
 
-    const timeoutContext =
-      this.timeoutContext ??
-      (typeof timeoutMS === 'number'
-        ? TimeoutContext.create({
-            serverSelectionTimeoutMS: this.clientOptions.serverSelectionTimeoutMS,
-            socketTimeoutMS: this.clientOptions.socketTimeoutMS,
-            timeoutMS
-          })
-        : null);
-
     try {
-      await executeOperation(this.client, operation, timeoutContext);
+      await executeOperation(this.client, operation);
       this.commitAttempted = undefined;
       return;
     } catch (firstCommitError) {
@@ -534,7 +521,7 @@ export class ClientSession
             bypassPinningCheck: true
           });
           op.maxAttempts = remainingAttempts;
-          await executeOperation(this.client, op, timeoutContext);
+          await executeOperation(this.client, op);
           return;
         } catch (retryCommitError) {
           // If the retry failed, we process that error instead of the original
@@ -602,26 +589,8 @@ export class ClientSession
       recoveryToken?: Document;
     } = { abortTransaction: 1 };
 
-    const timeoutMS =
-      typeof options?.timeoutMS === 'number'
-        ? options.timeoutMS
-        : this.timeoutContext?.csotEnabled()
-          ? this.timeoutContext.timeoutMS // refresh timeoutMS for abort operation
-          : typeof this.timeoutMS === 'number'
-            ? this.timeoutMS
-            : null;
-
-    const timeoutContext =
-      timeoutMS != null
-        ? TimeoutContext.create({
-            timeoutMS,
-            serverSelectionTimeoutMS: this.clientOptions.serverSelectionTimeoutMS,
-            socketTimeoutMS: this.clientOptions.socketTimeoutMS
-          })
-        : null;
-
     const wc = this.transaction.options.writeConcern ?? this.clientOptions?.writeConcern;
-    if (wc != null && timeoutMS == null) {
+    if (wc != null) {
       WriteConcern.apply(command, { wtimeoutMS: 10000, w: 'majority', ...wc });
     }
 
@@ -636,7 +605,7 @@ export class ClientSession
     });
 
     try {
-      await executeOperation(this.client, operation, timeoutContext);
+      await executeOperation(this.client, operation);
       this.unpin();
       return;
     } catch (firstAbortError) {
@@ -649,7 +618,7 @@ export class ClientSession
 
       if (firstAbortError instanceof MongoError && isRetryableWriteError(firstAbortError)) {
         try {
-          await executeOperation(this.client, operation, timeoutContext);
+          await executeOperation(this.client, operation);
           return;
         } catch (secondAbortError) {
           if (secondAbortError.name === 'MongoRuntimeError') throw secondAbortError;
@@ -716,25 +685,14 @@ export class ClientSession
     options?: TransactionOptions & {
       /**
        * Configures a timeoutMS expiry for the entire withTransactionCallback.
-       *
-       * @remarks
-       * - The remaining timeout will not be applied to callback operations that do not use the ClientSession.
-       * - Overriding timeoutMS for operations executed using the explicit session inside the provided callback will result in a client-side error.
+       * @deprecated `timeoutMS` has no effect and will be removed in a future release.
        */
       timeoutMS?: number;
     }
   ): Promise<T> {
     const MAX_TIMEOUT = 120_000;
 
-    const timeoutMS = options?.timeoutMS ?? this.timeoutMS ?? null;
-    this.timeoutContext =
-      timeoutMS != null
-        ? TimeoutContext.create({
-            timeoutMS,
-            serverSelectionTimeoutMS: this.clientOptions.serverSelectionTimeoutMS,
-            socketTimeoutMS: this.clientOptions.socketTimeoutMS
-          })
-        : null;
+    // timeoutMS is a no-op, so a CSOT timeout context is never created
 
     // 1. Define the following:
     // 1.1 Record the current monotonic time, which will be used to enforce the 120-second / CSOT timeout before later retry attempts.

package/src/sort.ts

@@ -81,7 +81,7 @@ function isReadonlyArray<T>(value: any): value is readonly T[] {
 
 /** @internal */
 function pairToMap(v: readonly [string, SortDirection]): SortForCmd {
-  return new Map([[`${v[0]}`, prepareDirection([v[1]])]]);
+  return new Map([[`${v[0]}`, prepareDirection(v[1])]]);
 }
 
 /** @internal */

package/src/timeout.ts

@@ -150,23 +150,12 @@ function isLegacyTimeoutContextOptions(v: unknown): v is LegacyTimeoutContextOpt
   );
 }
 
-function isCSOTTimeoutContextOptions(v: unknown): v is CSOTTimeoutContextOptions {
-  return (
-    v != null &&
-    typeof v === 'object' &&
-    'serverSelectionTimeoutMS' in v &&
-    typeof v.serverSelectionTimeoutMS === 'number' &&
-    'timeoutMS' in v &&
-    typeof v.timeoutMS === 'number'
-  );
-}
-
 /** @internal */
 export abstract class TimeoutContext {
   static create(options: TimeoutContextOptions): TimeoutContext {
     if (options.session?.timeoutContext != null) return options.session?.timeoutContext;
-    if (isCSOTTimeoutContextOptions(options)) return new CSOTTimeoutContext(options);
-    else if (isLegacyTimeoutContextOptions(options)) return new LegacyTimeoutContext(options);
+    // timeoutMS is a no-op, so a CSOT context is never created
+    if (isLegacyTimeoutContextOptions(options)) return new LegacyTimeoutContext(options);
     else throw new MongoRuntimeError('Unrecognized options');
   }
 

package/src/utils.ts

@@ -4,6 +4,7 @@ import { promises as fs } from 'fs';
 import * as http from 'http';
 import * as process from 'process';
 import { clearTimeout, setTimeout } from 'timers';
+import { domainToASCII } from 'url';
 
 import {
   ByteUtils,
@@ -29,7 +30,7 @@ import {
   MongoParseError,
   MongoRuntimeError
 } from './error';
-import type { MongoClient } from './mongo_client';
+import type { MongoClient, MongoOptions } from './mongo_client';
 import { type Abortable } from './mongo_types';
 import type { CommandOperationOptions, OperationParent } from './operations/command';
 import type { Hint, OperationOptions } from './operations/operation';
@@ -493,12 +494,19 @@ export function resolveTimeoutOptions<T extends Partial<TimeoutContextOptions>>(
 ): T &
   Pick<
     MongoClient['s']['options'],
-    'timeoutMS' | 'serverSelectionTimeoutMS' | 'waitQueueTimeoutMS' | 'socketTimeoutMS'
-  > {
-  const { socketTimeoutMS, serverSelectionTimeoutMS, waitQueueTimeoutMS, timeoutMS } =
-    client.s.options;
-  return { socketTimeoutMS, serverSelectionTimeoutMS, waitQueueTimeoutMS, timeoutMS, ...options };
+    'serverSelectionTimeoutMS' | 'waitQueueTimeoutMS' | 'socketTimeoutMS'
+  > & { timeoutMS?: undefined } {
+  const { socketTimeoutMS, serverSelectionTimeoutMS, waitQueueTimeoutMS } = client.s.options;
+  // timeoutMS is a no-op, so it is never forwarded
+  return {
+    socketTimeoutMS,
+    serverSelectionTimeoutMS,
+    waitQueueTimeoutMS,
+    ...options,
+    timeoutMS: undefined
+  };
 }
+
 /**
  * Merge inherited properties from parent into options, prioritizing values from options,
  * then values from parent.
@@ -514,7 +522,6 @@ export function resolveOptions<T extends CommandOperationOptions>(
 ): T {
   const result: T = Object.assign({}, options, resolveBSONOptions(options, parent));
 
-  const timeoutMS = options?.timeoutMS ?? parent?.timeoutMS;
   // Users cannot pass a readConcern/writeConcern to operations in a transaction
   const session = options?.session;
 
@@ -524,35 +531,20 @@ export function resolveOptions<T extends CommandOperationOptions>(
       result.readConcern = readConcern;
     }
 
-    let writeConcern = WriteConcern.fromOptions(options) ?? parent?.writeConcern;
+    const writeConcern = WriteConcern.fromOptions(options) ?? parent?.writeConcern;
     if (writeConcern) {
-      if (timeoutMS != null) {
-        writeConcern = WriteConcern.fromOptions({
-          writeConcern: {
-            ...writeConcern,
-            wtimeout: undefined,
-            wtimeoutMS: undefined
-          }
-        });
-      }
       result.writeConcern = writeConcern;
     }
   }
 
-  result.timeoutMS = timeoutMS;
+  // timeoutMS is a no-op, so it is never propagated to the operation
+  result.timeoutMS = undefined;
 
   const readPreference = ReadPreference.fromOptions(options) ?? parent?.readPreference;
   if (readPreference) {
     result.readPreference = readPreference;
   }
 
-  const isConvenientTransaction = session?.explicit && session?.timeoutContext != null;
-  if (isConvenientTransaction && options?.timeoutMS != null) {
-    throw new MongoInvalidArgumentError(
-      'An operation cannot be given a timeoutMS setting when inside a withTransaction call that has a timeoutMS setting'
-    );
-  }
-
   return result;
 }
 
@@ -1151,14 +1143,12 @@ export function parseUnsignedInteger(value: unknown): number | null {
  * If a DNS server were to become compromised SRV records would still need to
  * advertise addresses that are under the same domain as the srvHost.
  *
- * @param address - The address to check against a domain
+ * @param address - The address to check against a domain, already normalized with {@link normalizeDnsName}
  * @param srvHost - The domain to check the provided address against
  * @returns void
  */
-export function checkParentDomainMatch(address: string, srvHost: string): void {
-  // Remove trailing dot if exists on either the resolved address or the srv hostname
-  const normalizedAddress = address.endsWith('.') ? address.slice(0, address.length - 1) : address;
-  const normalizedSrvHost = srvHost.endsWith('.') ? srvHost.slice(0, srvHost.length - 1) : srvHost;
+export function checkParentDomainMatch(normalizedAddress: string, srvHost: string): void {
+  const normalizedSrvHost = normalizeDnsName(srvHost);
 
   const allCharacterBeforeFirstDot = /^.*?\./;
   const srvIsLessThanThreeParts = normalizedSrvHost.split('.').length < 3;
@@ -1187,6 +1177,82 @@ export function checkParentDomainMatch(address: string, srvHost: string): void {
   }
 }
 
+/**
+ * Forbidden domain code points, per the WHATWG URL Standard. `domainToASCII` parses its input as
+ * URL text, so names containing these characters are rejected before conversion.
+ */
+// eslint-disable-next-line no-control-regex
+const FORBIDDEN_DOMAIN_CODE_POINTS = /[\u0000-\u0020\u007F#%/:<>?@[\\\]^|]/;
+
+/**
+ * Converts a DNS name to its lowercase A-label (Punycode) form, using the WHATWG URL Standard's
+ * domain parser (with beStrict false).
+ *
+ * @returns the converted name, or `null` if the name cannot be converted
+ */
+export function dnsNameToASCII(name: string): string | null {
+  if (FORBIDDEN_DOMAIN_CODE_POINTS.test(name)) {
+    return null;
+  }
+  // The standard returns an ASCII name lowercased, even if its `xn--` labels are not valid A-labels
+  // (https://github.com/whatwg/url/commit/a8d5ca3716c3). Node.js only does so from 24.20.0, which
+  // updated Ada to 4.0.0, so it is done here to behave the same on every Node.js version.
+  const ascii = /^\p{ASCII}*$/u.test(name) ? name.toLowerCase() : domainToASCII(name);
+  return ascii === '' ? null : ascii;
+}
+
+/**
+ * Normalizes a DNS host name so it can be compared against another normalized host name, as
+ * required by the Initial DNS Seedlist Discovery specification: a trailing `.` is removed, and the
+ * name is converted to its lowercase A-label (Punycode) form.
+ *
+ * @throws MongoAPIError if the name is not a valid DNS host name
+ */
+export function normalizeDnsName(name: string): string {
+  const withoutTrailingDot = name.endsWith('.') ? name.slice(0, -1) : name;
+  const normalized = dnsNameToASCII(withoutTrailingDot);
+  if (normalized == null) {
+    throw new MongoAPIError('Invalid DNS host name');
+  }
+  return normalized;
+}
+
+/**
+ * Verifies a host name returned by an SRV lookup. Exactly one verification applies:
+ * - with `srvHostValidator`, the validator's return value is the complete verdict
+ * - with `srvAllowedHostsSuffix`, the host must end with the (already normalized) suffix
+ * - otherwise, the host must share the parent domain of `srvHost`, see {@link checkParentDomainMatch}
+ *
+ * @param host - A host name returned by an SRV lookup, already normalized with {@link normalizeDnsName}
+ * @param srvHost - The host from the `mongodb+srv` connection string
+ * @throws MongoAPIError if the host fails verification, or the validator throws or returns a
+ * non-boolean value (the `srvHostValidator` option transform wraps the validator to throw in those
+ * cases)
+ */
+export function verifySrvHost(
+  host: string,
+  srvHost: string,
+  options: Pick<MongoOptions, 'srvAllowedHostsSuffix' | 'srvHostValidator'>
+): void {
+  const { srvAllowedHostsSuffix, srvHostValidator } = options;
+
+  if (srvHostValidator != null) {
+    if (!srvHostValidator(host)) {
+      throw new MongoAPIError('Server record was rejected by srvHostValidator');
+    }
+    return;
+  }
+
+  if (srvAllowedHostsSuffix != null) {
+    if (!host.endsWith(srvAllowedHostsSuffix)) {
+      throw new MongoAPIError('Server record does not end with srvAllowedHostsSuffix');
+    }
+    return;
+  }
+
+  checkParentDomainMatch(host, srvHost);
+}
+
 /**
  * Perform a get request that returns status and body.
  * @internal