mongodb 7.7.0 → 7.8.0

package/src/gridfs/upload.ts

@@ -2,15 +2,14 @@ import { Writable } from 'stream';
 
 import { ByteUtils, type Document, ObjectId } from '../bson';
 import type { Collection } from '../collection';
-import { CursorTimeoutMode } from '../cursor/abstract_cursor';
 import {
   MongoAPIError,
   MONGODB_ERROR_CODES,
   MongoError,
   MongoOperationTimeoutError
 } from '../error';
-import { CSOTTimeoutContext } from '../timeout';
-import { type Callback, resolveTimeoutOptions, squashError } from '../utils';
+import { type CSOTTimeoutContext } from '../timeout';
+import { type Callback, squashError } from '../utils';
 import type { WriteConcernOptions } from '../write_concern';
 import { WriteConcern } from './../write_concern';
 import type { GridFSFile } from './download';
@@ -33,8 +32,8 @@ export interface GridFSBucketWriteStreamOptions extends WriteConcernOptions {
   /** Object to store in the file document's `metadata` field */
   metadata?: Document;
   /**
-   * @experimental
    * 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;
 }
@@ -132,13 +131,6 @@ export class GridFSBucketWriteStream extends Writable {
       errored: false,
       aborted: false
     };
-
-    if (options.timeoutMS != null)
-      this.timeoutContext = new CSOTTimeoutContext({
-        timeoutMS: options.timeoutMS,
-        serverSelectionTimeoutMS: resolveTimeoutOptions(this.bucket.s.db.client, {})
-          .serverSelectionTimeoutMS
-      });
   }
 
   /**
@@ -214,7 +206,7 @@ export class GridFSBucketWriteStream extends Writable {
       `Upload timed out after ${this.timeoutContext?.timeoutMS}ms`
     );
 
-    await this.chunks.deleteMany({ files_id: this.id }, { timeoutMS: remainingTimeMS });
+    await this.chunks.deleteMany({ files_id: { $eq: this.id } }, { timeoutMS: remainingTimeMS });
   }
 }
 
@@ -248,7 +240,6 @@ async function checkChunksIndex(stream: GridFSBucketWriteStream): Promise<void>
   try {
     indexes = await stream.chunks
       .listIndexes({
-        timeoutMode: remainingTimeMS != null ? CursorTimeoutMode.LIFETIME : undefined,
         timeoutMS: remainingTimeMS
       })
       .toArray();
@@ -272,12 +263,7 @@ async function checkChunksIndex(stream: GridFSBucketWriteStream): Promise<void>
     remainingTimeMS = stream.timeoutContext?.getRemainingTimeMSOrThrow(
       `Upload timed out after ${stream.timeoutContext?.timeoutMS}ms`
     );
-    await stream.chunks.createIndex(index, {
-      ...stream.writeConcern,
-      background: true,
-      unique: true,
-      timeoutMS: remainingTimeMS
-    });
+    await stream.chunks.createIndex(index, { unique: true }, { timeoutMS: remainingTimeMS });
   }
 }
 
@@ -353,7 +339,6 @@ async function checkIndexes(stream: GridFSBucketWriteStream): Promise<void> {
     `Upload timed out after ${stream.timeoutContext?.timeoutMS}ms`
   );
   const listIndexesOptions = {
-    timeoutMode: remainingTimeMS != null ? CursorTimeoutMode.LIFETIME : undefined,
     timeoutMS: remainingTimeMS
   };
   try {
@@ -379,7 +364,7 @@ async function checkIndexes(stream: GridFSBucketWriteStream): Promise<void> {
       `Upload timed out after ${stream.timeoutContext?.timeoutMS}ms`
     );
 
-    await stream.files.createIndex(index, { background: false, timeoutMS: remainingTimeMS });
+    await stream.files.createIndex(index, {}, { timeoutMS: remainingTimeMS });
   }
 
   await checkChunksIndex(stream);

package/src/index.ts

@@ -530,11 +530,13 @@ export type {
 export type { IndexInformationOptions } from './operations/indexes';
 export type {
   CreateIndexesOptions,
+  CreateIndexOptions,
   DropIndexesOptions,
   IndexDescription,
   IndexDescriptionCompact,
   IndexDescriptionInfo,
   IndexDirection,
+  IndexOptions,
   IndexSpecification,
   ListIndexesOptions
 } from './operations/indexes';

package/src/mongo_client.ts

@@ -143,8 +143,8 @@ export interface MongoClientOptions extends BSONSerializeOptions, SupportedNodeC
   /** Specifies the name of the replica set, if the mongod is a member of a replica set. */
   replicaSet?: string;
   /**
-   * @experimental
    * 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;
   /** Enables or disables TLS/SSL for the connection. */
@@ -183,6 +183,46 @@ export interface MongoClientOptions extends BSONSerializeOptions, SupportedNodeC
    * Querying this DNS URI is expected to respond with SRV records
    */
   srvServiceName?: string;
+  /**
+   * A host name suffix that every host returned by the SRV lookup must end with. It replaces the
+   * default verification, which requires returned hosts to share the parent domain of the SRV host
+   * name (the SRV host name without its leftmost label). Only valid with a `mongodb+srv` connection
+   * string, and cannot be combined with `srvHostValidator`.
+   *
+   * For example, with `mongodb+srv://cluster.mongodb.mydomain.net`, the default verification
+   * rejects `host1.us-east-1.mydomain.net`, while `srvAllowedHostsSuffix: '.mydomain.net'` accepts
+   * it. A leading `.` is optional. Internationalized domain names may be given in Unicode or in
+   * A-label (`xn--`) form: the value is converted to lowercase A-label form, and a value that cannot
+   * be converted is an error. The value must contain at least two labels, unless it is one of the
+   * names reserved for private or special use: `test`, `localhost`, `invalid`, `example`, `local`,
+   * `internal`, `corp`, `home`, or `mail`.
+   *
+   * **WARNING: Modifying the default SRV domain name validation can create vulnerabilities.**
+   * SRV host verification prevents a spoofed DNS response from directing the driver to arbitrary
+   * hosts, and this option widens the set of hosts such a response can direct it to. Configure the
+   * narrowest suffix that covers your deployment: for a seed of
+   * `cluster.test.internal.example.com`, prefer `.internal.example.com` over `.example.com`.
+   */
+  srvAllowedHostsSuffix?: string;
+  /**
+   * A synchronous function that decides whether a host returned by the SRV lookup may be used. It
+   * receives the host name, normalized to lowercase A-label (Punycode) form without a trailing `.`,
+   * and must return `true` to accept the host or `false` to reject it. Its return value replaces the
+   * default verification entirely: the driver applies no other checks to the host. Only valid with a
+   * `mongodb+srv` connection string, cannot be combined with `srvAllowedHostsSuffix`, and cannot be
+   * set in the connection string.
+   *
+   * The function runs synchronously during SRV resolution and SRV polling, so it must not block.
+   *
+   * If the function throws during the initial SRV lookup, `connect()` rejects with a
+   * `MongoAPIError` whose `cause` is the thrown error. During SRV polling, the host is rejected
+   * instead and no error is raised.
+   *
+   * **WARNING: Modifying the default SRV domain name validation can create vulnerabilities.**
+   * SRV host verification prevents a spoofed DNS response from directing the driver to arbitrary
+   * hosts, and a validator that accepts too broadly removes that protection.
+   */
+  srvHostValidator?: (host: string) => boolean;
   /** The maximum number of connections in the connection pool. */
   maxPoolSize?: number;
   /** The minimum number of connections in the connection pool. */
@@ -562,8 +602,9 @@ export class MongoClient extends TypedEventEmitter<MongoClientEvents> implements
     return this.s.bsonOptions;
   }
 
+  /** @deprecated `timeoutMS` has no effect and will be removed in a future release. */
   get timeoutMS(): number | undefined {
-    return this.s.options.timeoutMS;
+    return undefined;
   }
 
   /**
@@ -874,12 +915,6 @@ export class MongoClient extends TypedEventEmitter<MongoClientEvents> implements
    * **Connection Pooling Impact:** Calling `connect` will populate the connection pool with one connection
    * to a server selected by the client's configured `readPreference` (defaults to primary).
    *
-   * @remarks
-   * **Timeout Behavior:** When using `timeoutMS`, the connection establishment time does not count against
-   * the timeout for subsequent operations. This means `connect` runs without a `timeoutMS` limit, while
-   * your database operations will still respect the configured timeout. If you need predictable operation
-   * timing with `timeoutMS`, call `connect` explicitly before performing operations.
-   *
    * @see https://www.mongodb.com/docs/manual/reference/connection-string/
    */
   static async connect(url: string, options?: MongoClientOptions): Promise<MongoClient> {
@@ -961,59 +996,6 @@ export class MongoClient extends TypedEventEmitter<MongoClientEvents> implements
    * watch() accepts two generic arguments for distinct use cases:
    * - The first is to provide the schema that may be defined for all the data within the current cluster
    * - The second is to override the shape of the change stream document entirely, if it is not provided the type will default to ChangeStreamDocument of the first argument
-   *
-   * @remarks
-   * When `timeoutMS` is configured for a change stream, it will have different behaviour depending
-   * on whether the change stream is in iterator mode or emitter mode. In both cases, a change
-   * stream will time out if it does not receive a change event within `timeoutMS` of the last change
-   * event.
-   *
-   * Note that if a change stream is consistently timing out when watching a collection, database or
-   * client that is being changed, then this may be due to the server timing out before it can finish
-   * processing the existing oplog. To address this, restart the change stream with a higher
-   * `timeoutMS`.
-   *
-   * If the change stream times out the initial aggregate operation to establish the change stream on
-   * the server, then the client will close the change stream. If the getMore calls to the server
-   * time out, then the change stream will be left open, but will throw a MongoOperationTimeoutError
-   * when in iterator mode and emit an error event that returns a MongoOperationTimeoutError in
-   * emitter mode.
-   *
-   * To determine whether or not the change stream is still open following a timeout, check the
-   * {@link ChangeStream.closed} getter.
-   *
-   * @example
-   * In iterator mode, if a next() call throws a timeout error, it will attempt to resume the change stream.
-   * The next call can just be retried after this succeeds.
-   * ```ts
-   * const changeStream = collection.watch([], { timeoutMS: 100 });
-   * try {
-   *     await changeStream.next();
-   * } catch (e) {
-   *     if (e instanceof MongoOperationTimeoutError && !changeStream.closed) {
-   *       await changeStream.next();
-   *     }
-   *     throw e;
-   * }
-   * ```
-   *
-   * @example
-   * In emitter mode, if the change stream goes `timeoutMS` without emitting a change event, it will
-   * emit an error event that returns a MongoOperationTimeoutError, but will not close the change
-   * stream unless the resume attempt fails. There is no need to re-establish change listeners as
-   * this will automatically continue emitting change events once the resume attempt completes.
-   *
-   * ```ts
-   * const changeStream = collection.watch([], { timeoutMS: 100 });
-   * changeStream.on('change', console.log);
-   * changeStream.on('error', e => {
-   *     if (e instanceof MongoOperationTimeoutError && !changeStream.closed) {
-   *         // do nothing
-   *     } else {
-   *         changeStream.close();
-   *     }
-   * });
-   * ```
    * @param pipeline - An array of {@link https://www.mongodb.com/docs/manual/reference/operator/aggregation-pipeline/|aggregation pipeline stages} through which to pass change stream documents. This allows for filtering (using $match) and manipulating the change stream documents.
    * @param options - Optional settings for the command
    * @typeParam TSchema - Type of the data being detected by the change stream
@@ -1092,6 +1074,8 @@ export interface MongoOptions
   appName?: string;
   hosts: HostAddress[];
   srvHost?: string;
+  srvAllowedHostsSuffix?: string;
+  srvHostValidator?: (host: string) => boolean;
   credentials?: MongoCredentials;
   readPreference: ReadPreference;
   readConcern: ReadConcern;
@@ -1173,6 +1157,7 @@ export interface MongoOptions
    * TODO: NODE-5671 - remove internal flag
    */
   mongodbLogPath?: 'stderr' | 'stdout' | MongoDBLogWritable;
+  /** @deprecated `timeoutMS` has no effect and will be removed in a future release. */
   timeoutMS?: number;
   /** @internal */
   __skipPingOnConnect?: boolean;

package/src/operations/command.ts

@@ -2,12 +2,7 @@ import { type Connection } from '..';
 import type { BSONSerializeOptions, Document } from '../bson';
 import { MIN_SUPPORTED_RAW_DATA_WIRE_VERSION } from '../cmap/wire_protocol/constants';
 import { MongoInvalidArgumentError } from '../error';
-import {
-  decorateWithExplain,
-  Explain,
-  type ExplainOptions,
-  validateExplainTimeoutOptions
-} from '../explain';
+import { decorateWithExplain, Explain, type ExplainOptions } from '../explain';
 import { ReadConcern } from '../read_concern';
 import type { ReadPreference } from '../read_preference';
 import type { ServerCommandOptions } from '../sdam/server';
@@ -99,7 +94,6 @@ export abstract class CommandOperation<T> extends AbstractOperation<T> {
 
     if (this.hasAspect(Aspect.EXPLAINABLE)) {
       this.explain = Explain.fromOptions(options);
-      if (this.explain) validateExplainTimeoutOptions(this.options, this.explain);
     } else if (options?.explain != null) {
       throw new MongoInvalidArgumentError(`Option "explain" is not supported on this command`);
     }

package/src/operations/create_collection.ts

@@ -95,7 +95,7 @@ export interface CreateCollectionOptions extends Omit<CommandOperationOptions, '
   clusteredIndex?: ClusteredCollectionOptions;
   /** The number of seconds after which a document in a timeseries or clustered collection expires. */
   expireAfterSeconds?: number;
-  /** @experimental */
+  /** Queryable Encryption field schema attached at collection creation. **/
   encryptedFields?: Document;
   /**
    * If set, enables pre-update and post-update document events to be included for any
@@ -207,7 +207,9 @@ export async function createCollections<TSchema extends Document>(
       db,
       name,
       { __safeContent__: 1 },
-      { session: options.session }
+      false,
+      { session: options.session },
+      undefined
     );
     await executeOperation(db.client, createIndexOp, timeoutContext);
   }

package/src/operations/drop.ts

@@ -12,7 +12,7 @@ import { Aspect, defineAspects } from './operation';
 
 /** @public */
 export interface DropCollectionOptions extends Omit<CommandOperationOptions, 'rawData'> {
-  /** @experimental */
+  /** Queryable Encryption field schema used during collection drop so associated state collections are dropped too. **/
   encryptedFields?: Document;
 }
 

package/src/operations/indexes.ts

@@ -93,7 +93,11 @@ export interface IndexInformationOptions extends ListIndexesOptions {
   full?: boolean;
 }
 
-/** @public */
+/**
+ * @public
+ *
+ * Loosely aligns with `IndexModel` from the spec.
+ * */
 export interface IndexDescription
   extends Pick<
     CreateIndexesOptions,
@@ -160,6 +164,144 @@ export interface CreateIndexesOptions extends Omit<CommandOperationOptions, 'wri
   wildcardProjection?: Document;
   /** Specifies that the index should exist on the target collection but should not be used by the query planner when executing operations. */
   hidden?: boolean;
+  /** Collation */
+  collation?: CollationOptions;
+}
+
+// Maps to `IndexOptions` in
+// https://github.com/mongodb/specifications/blob/6f64d0ee3ae49edbdb30eb995f3e29549e8cfa6a/source/index-management/index-management.md#common-api-components
+/** @public */
+export interface IndexOptions extends Document {
+  /**
+   * Optionally specifies the length in time, in seconds, for documents to remain in
+   * a collection.
+   */
+  expireAfterSeconds?: number;
+
+  /**
+   * Optionally specify a specific name for the index outside of the default generated
+   * name. If none is provided then the name is generated in the format "[field]_[direction]".
+   *
+   * Note that if an index is created for the same key pattern with different collations,
+   * a name must be provided by the user to avoid ambiguity.
+   *
+   * @example For an index of name: 1, age: -1, the generated name would be "name_1_age_-1".
+   */
+  name?: string;
+
+  /**
+   * Optionally tells the index to only reference documents with the specified field in
+   * the index.
+   */
+  sparse?: boolean;
+
+  /**
+   * Optionally allows users to configure the storage engine on a per-index basis when creating
+   * an index.
+   */
+  storageEngine?: Document;
+
+  /**
+   * Optionally forces the index to be unique.
+   */
+  unique?: boolean;
+
+  /**
+   * Optionally specifies the index version number, either 0 or 1.
+   */
+  version?: number;
+
+  /**
+   * Optionally specifies the default language for text indexes.
+   * Is 'english' if none is provided.
+   */
+  defaultLanguage?: string;
+
+  /**
+   * Optionally Specifies the field in the document to override the language.
+   */
+  languageOverride?: string;
+
+  /**
+   * Optionally provides the text index version number.
+   */
+  textIndexVersion?: number;
+
+  /**
+   * Optionally specifies fields in the index and their corresponding weight values.
+   */
+  weights?: Document;
+
+  /**
+   * Optionally specifies the 2dsphere index version number.
+   */
+  '2dsphereIndexVersion'?: number;
+
+  /**
+   * Optionally specifies the precision of the stored geo hash in the 2d index, from 1 to 32.
+   */
+  bits?: number;
+
+  /**
+   * Optionally sets the maximum boundary for latitude and longitude in the 2d index.
+   */
+  max?: number;
+
+  /**
+   * Optionally sets the minimum boundary for latitude and longitude in the index in a
+   * 2d index.
+   */
+  min?: number;
+
+  /**
+   * Optionally specifies the number of units within which to group the location values
+   * in a geo haystack index.
+   */
+  bucketSize?: number;
+
+  /**
+   * Optionally specifies a filter for use in a partial index. Only documents that match the
+   * filter expression are included in the index.
+   */
+  partialFilterExpression?: Document;
+
+  /**
+   * Optionally specifies a collation to use for the index. If not specified, no collation is
+   * sent and the default collation of the collection server-side is used.
+   */
+  collation?: CollationOptions;
+
+  /**
+   * Optionally specifies the wildcard projection of a wildcard index.
+   */
+  wildcardProjection?: Document;
+
+  /**
+   * Optionally specifies that the index should exist on the target collection but should not be used by the query
+   * planner when executing operations.
+   *
+   * This option is only supported by servers \>= 4.4.
+   */
+  hidden?: boolean;
+}
+
+/** @public */
+export interface CreateIndexOptions extends Omit<CommandOperationOptions, 'collation' | 'explain'> {
+  /**
+   * Specifies how many data-bearing members of a replica set, including the primary, must
+   * complete the index builds successfully before the primary marks the indexes as ready.
+   *
+   * This option accepts the same values for the "w" field in a write concern plus "votingMembers",
+   * which indicates all voting data-bearing nodes.
+   *
+   * This option is only supported by servers \>= 4.4. Drivers MUST manually raise an error if this option
+   * is specified when creating an index on a pre 4.4 server. See the Q&A section for the rationale behind this.
+   *
+   * @remarks This option is sent only if the caller explicitly provides a value. The default is to not send a value.
+   *
+   * @sinceServerVersion 4.4
+   */
+  commitQuorum?: number | string;
 }
 
 function isSingleIndexTuple(t: unknown): t is [string, IndexDirection] {
@@ -197,19 +339,36 @@ function constructIndexDescriptionMap(indexSpec: IndexSpecification): Map<string
 }
 
 /**
- * Receives an index description and returns a modified index description which has had invalid options removed
- * from the description and has mapped the `version` option to the `v` option.
+ * Index options whose public name on {@link IndexOptions} differs from the field name the
+ * `createIndexes` command expects.
+ */
+const INDEX_OPTION_RENAMES = new Map([
+  ['version', 'v'],
+  ['defaultLanguage', 'default_language'],
+  ['languageOverride', 'language_override']
+]);
+
+/**
+ * Receives an index description and returns a modified index description which has mapped the
+ * options in {@link INDEX_OPTION_RENAMES} to the field names the `createIndexes` command expects.
+ *
+ * When `allowUnknownIndexOptions` is `false` (the default), options that are not in the driver's
+ * `VALID_INDEX_OPTIONS` allowlist are removed from the description. When `true`, all options are
+ * retained and passed through to the server for validation.
  */
 function resolveIndexDescription(
-  description: IndexDescription
+  description: IndexDescription,
+  // TODO(NODE-7868): Remove allowUnknownIndexOptions with a default behavior of true in a future major version release
+  allowUnknownIndexOptions: boolean
 ): Omit<ResolvedIndexDescription, 'key'> {
-  const validProvidedOptions = Object.entries(description).filter(([optionName]) =>
-    VALID_INDEX_OPTIONS.has(optionName)
+  const providedOptions = Object.entries(description).filter(
+    ([optionName]) =>
+      // Ensure `key` is removed, even when `allowUnknownIndexOptions` is true
+      optionName !== 'key' && (allowUnknownIndexOptions || VALID_INDEX_OPTIONS.has(optionName))
   );
 
   return Object.fromEntries(
-    // we support the `version` option, but the `createIndexes` command expects it to be the `v`
-    validProvidedOptions.map(([name, value]) => (name === 'version' ? ['v', value] : [name, value]))
+    providedOptions.map(([name, value]) => [INDEX_OPTION_RENAMES.get(name) ?? name, value])
   );
 }
 
@@ -251,11 +410,13 @@ export class CreateIndexesOperation extends CommandOperation<string[]> {
     parent: OperationParent,
     collectionName: string,
     indexes: IndexDescription[],
-    options?: CreateIndexesOptions
+    // TODO(NODE-7868): Remove allowUnknownIndexOptions with a default behavior of true in a future major version release
+    allowUnknownIndexOptions: boolean,
+    commandOptions: CreateIndexesOptions | CreateIndexOptions | undefined
   ) {
-    super(parent, options);
+    super(parent, commandOptions);
 
-    this.options = options ?? {};
+    this.options = { ...commandOptions };
     // collation is set on each index, it should not be defined at the root
     this.options.collation = undefined;
     this.collectionName = collectionName;
@@ -264,7 +425,8 @@ export class CreateIndexesOperation extends CommandOperation<string[]> {
       const key =
         userIndex.key instanceof Map ? userIndex.key : new Map(Object.entries(userIndex.key));
       const name = userIndex.name ?? Array.from(key).flat().join('_');
-      const validIndexOptions = resolveIndexDescription(userIndex);
+
+      const validIndexOptions = resolveIndexDescription(userIndex, allowUnknownIndexOptions);
       return {
         ...validIndexOptions,
         name,
@@ -274,24 +436,58 @@ export class CreateIndexesOperation extends CommandOperation<string[]> {
     this.ns = parent.s.namespace;
   }
 
+  /**
+   * Index options are carried by the individual {@link IndexDescription} entries of `indexes`,
+   * so the only options bag this factory takes is the command one.
+   */
   static fromIndexDescriptionArray(
     parent: OperationParent,
     collectionName: string,
     indexes: IndexDescription[],
-    options?: CreateIndexesOptions
+    // TODO(NODE-7868): Remove allowUnknownIndexOptions with a default behavior of true in a future major version release
+    allowUnknownIndexOptions: boolean,
+    commandOptions: CreateIndexesOptions | undefined
   ): CreateIndexesOperation {
-    return new CreateIndexesOperation(parent, collectionName, indexes, options);
+    return new CreateIndexesOperation(
+      parent,
+      collectionName,
+      indexes,
+      allowUnknownIndexOptions,
+      commandOptions
+    );
   }
 
   static fromIndexSpecification(
     parent: OperationParent,
     collectionName: string,
     indexSpec: IndexSpecification,
-    options: CreateIndexesOptions = {}
+    allowUnknownIndexOptions: boolean,
+    indexOptions: IndexOptions | undefined,
+    commandOptions: CreateIndexOptions | undefined
+  ): CreateIndexesOperation;
+
+  static fromIndexSpecification(
+    parent: OperationParent,
+    collectionName: string,
+    indexSpec: IndexSpecification,
+    allowUnknownIndexOptions: boolean,
+    indexOptions: CreateIndexesOptions | IndexOptions | undefined,
+    commandOptions: CreateIndexOptions | undefined
   ): CreateIndexesOperation {
     const key = constructIndexDescriptionMap(indexSpec);
-    const description: IndexDescription = { ...options, key };
-    return new CreateIndexesOperation(parent, collectionName, [description], options);
+    // If called with overload using `CreateIndexesOptions`, then indexOptions may contain combined index and command options
+    // These are filtered in CreateIndexesOperation using VALID_INDEX_OPTIONS.
+    // Otherwise, `IndexOptions` only contains index options (which is the ultimate goal anyway)
+    const description: IndexDescription = { ...indexOptions, key };
+    return new CreateIndexesOperation(
+      parent,
+      collectionName,
+      [description],
+      allowUnknownIndexOptions,
+      // TODO(NODE-7868): Remove the `?? indexOptions` fallback along with the two parameter path.
+      // Once `indexOptions` is index options only it must not reach the command root.
+      commandOptions ?? indexOptions
+    );
   }
 
   override get commandName() {

package/src/operations/operation.ts

@@ -39,8 +39,8 @@ export interface OperationOptions extends BSONSerializeOptions {
   omitMaxTimeMS?: boolean;
 
   /**
-   * @experimental
    * 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;
 }

package/src/operations/run_command.ts

@@ -16,8 +16,8 @@ export type RunCommandOptions = {
   /** The read preference */
   readPreference?: ReadPreferenceLike;
   /**
-   * @experimental
    * 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;
   /** @internal */

package/src/sdam/srv_polling.ts

@@ -3,7 +3,7 @@ import { clearTimeout, setTimeout } from 'timers';
 
 import { MongoRuntimeError } from '../error';
 import { TypedEventEmitter } from '../mongo_types';
-import { checkParentDomainMatch, HostAddress, noop, squashError } from '../utils';
+import { HostAddress, noop, normalizeDnsName, squashError, verifySrvHost } from '../utils';
 
 /**
  * @internal
@@ -25,6 +25,8 @@ export interface SrvPollerOptions {
   srvServiceName: string;
   srvMaxHosts: number;
   srvHost: string;
+  srvAllowedHostsSuffix?: string;
+  srvHostValidator?: (host: string) => boolean;
   heartbeatFrequencyMS: number;
 }
 
@@ -42,6 +44,8 @@ export class SrvPoller extends TypedEventEmitter<SrvPollerEvents> {
   generation: number;
   srvMaxHosts: number;
   srvServiceName: string;
+  srvAllowedHostsSuffix?: string;
+  srvHostValidator?: (host: string) => boolean;
   _timeout?: NodeJS.Timeout;
 
   /** @event */
@@ -58,6 +62,8 @@ export class SrvPoller extends TypedEventEmitter<SrvPollerEvents> {
     this.srvHost = options.srvHost;
     this.srvMaxHosts = options.srvMaxHosts ?? 0;
     this.srvServiceName = options.srvServiceName ?? 'mongodb';
+    this.srvAllowedHostsSuffix = options.srvAllowedHostsSuffix;
+    this.srvHostValidator = options.srvHostValidator;
     this.rescanSrvIntervalMS = 60000;
     this.heartbeatFrequencyMS = options.heartbeatFrequencyMS ?? 10000;
 
@@ -129,9 +135,12 @@ export class SrvPoller extends TypedEventEmitter<SrvPollerEvents> {
     const finalAddresses: dns.SrvRecord[] = [];
     for (const record of srvRecords) {
       try {
-        checkParentDomainMatch(record.name, this.srvHost);
-        finalAddresses.push(record);
+        const name = normalizeDnsName(record.name);
+        // A validator that throws is treated as rejecting the host, so polling continues
+        verifySrvHost(name, this.srvHost, this);
+        finalAddresses.push({ ...record, name });
       } catch (error) {
+        // TODO(NODE-4994): log the rejected host name, as the polling spec recommends
         squashError(error);
       }
     }