mongodb 7.7.0 → 7.8.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mongodb",
-  "version": "7.7.0",
+  "version": "7.8.0",
   "description": "The official MongoDB driver for Node.js",
   "main": "lib/index.js",
   "files": [

package/src/bulk/unordered.ts

@@ -112,7 +112,7 @@ export class UnorderedBulkOperation extends BulkOperationBase {
     if (batchType === BatchType.INSERT) {
       this.s.currentInsertBatch = this.s.currentBatch;
       this.s.bulkResult.insertedIds.push({
-        index: this.s.bulkResult.insertedIds.length,
+        index: this.s.currentIndex - 1,
         _id: (document as Document)._id
       });
     } else if (batchType === BatchType.UPDATE) {

package/src/change_stream.ts

@@ -20,7 +20,7 @@ import type { AggregateOptions } from './operations/aggregate';
 import type { OperationParent } from './operations/command';
 import { DeprioritizedServers } from './sdam/server_selection';
 import type { ServerSessionId } from './sessions';
-import { CSOTTimeoutContext, type TimeoutContext } from './timeout';
+import { type TimeoutContext } from './timeout';
 import { type AnyOptions, getTopology, type MongoDBNamespace, squashError } from './utils';
 
 const CHANGE_DOMAIN_TYPES = {
@@ -647,18 +647,17 @@ export class ChangeStream<
 
     this.pipeline = pipeline;
     this.options = { ...options };
-    let serverSelectionTimeoutMS: number;
+    // timeoutMS and timeoutMode are no-ops, so they must never reach the cursor options
+    this.options.timeoutMS = undefined;
+    this.options.timeoutMode = undefined;
     delete this.options.writeConcern;
 
     if (parent instanceof Collection) {
       this.type = CHANGE_DOMAIN_TYPES.COLLECTION;
-      serverSelectionTimeoutMS = parent.s.db.client.options.serverSelectionTimeoutMS;
     } else if (parent instanceof Db) {
       this.type = CHANGE_DOMAIN_TYPES.DATABASE;
-      serverSelectionTimeoutMS = parent.client.options.serverSelectionTimeoutMS;
     } else if (parent instanceof MongoClient) {
       this.type = CHANGE_DOMAIN_TYPES.CLUSTER;
-      serverSelectionTimeoutMS = parent.options.serverSelectionTimeoutMS;
     } else {
       throw new MongoChangeStreamError(
         'Parent provided to ChangeStream constructor must be an instance of Collection, Db, or MongoClient'
@@ -690,13 +689,6 @@ export class ChangeStream<
         this.cursorStream?.removeAllListeners('data');
       }
     });
-
-    if (this.options.timeoutMS != null) {
-      this.timeoutContext = new CSOTTimeoutContext({
-        timeoutMS: this.options.timeoutMS,
-        serverSelectionTimeoutMS
-      });
-    }
   }
 
   /** The cached resume token that is used to resume after the most recently returned change. */

package/src/client-side-encryption/client_encryption.ts

@@ -294,7 +294,7 @@ export class ClientEncryption {
   async rewrapManyDataKey(
     filter: Filter<DataKey>,
     options?: ClientEncryptionRewrapManyDataKeyProviderOptions
-  ): Promise<{ bulkWriteResult?: BulkWriteResult }> {
+  ): Promise<ClientEncryptionRewrapManyDataKeyResult> {
     let keyEncryptionKeyBson = undefined;
     if (options) {
       const keyEncryptionKey = Object.assign({ provider: options.provider }, options.masterKey);
@@ -927,7 +927,7 @@ export type TextQueryOptions = StringQueryOptions;
 
 /**
  * @public
- * @experimental
+ * Options interface for `rewrapManyDataKey`; selects the new KMS provider/masterKey for bulk key rotation.
  */
 export interface ClientEncryptionRewrapManyDataKeyProviderOptions {
   provider: ClientEncryptionDataKeyProvider;
@@ -987,35 +987,8 @@ export interface ClientEncryptionOptions {
   keyExpirationMS?: number;
 
   /**
-   * @experimental
-   *
    * The timeout setting to be used for all the operations on ClientEncryption.
-   *
-   * When provided, `timeoutMS` is used as the timeout for each operation executed on
-   * the ClientEncryption object.  For example:
-   *
-   * ```typescript
-   * const clientEncryption = new ClientEncryption(client, {
-   *  timeoutMS: 1_000
-   *  kmsProviders: { local: { key: '<KEY>' } }
-   * });
-   *
-   * // `1_000` is used as the timeout for createDataKey call
-   * await clientEncryption.createDataKey('local');
-   * ```
-   *
-   * If `timeoutMS` is configured on the provided client, the client's `timeoutMS` value
-   * will be used unless `timeoutMS` is also provided as a client encryption option.
-   *
-   * ```typescript
-   * const client = new MongoClient('<uri>', { timeoutMS: 2_000 });
-   *
-   * // timeoutMS is set to 1_000 on clientEncryption
-   * const clientEncryption = new ClientEncryption(client, {
-   *  timeoutMS: 1_000
-   *  kmsProviders: { local: { key: '<KEY>' } }
-   * });
-   * ```
+   * @deprecated `timeoutMS` has no effect and will be removed in a future release.
    */
   timeoutMS?: number;
 }
@@ -1144,7 +1117,7 @@ export interface ClientEncryptionCreateDataKeyProviderOptions {
    */
   keyAltNames?: string[] | undefined;
 
-  /** @experimental */
+  /** Optional 96-byte custom key material used when creating a data key instead of libmongocrypt’s random material. **/
   keyMaterial?: Buffer | Binary;
 
   /** @internal */
@@ -1153,7 +1126,7 @@ export interface ClientEncryptionCreateDataKeyProviderOptions {
 
 /**
  * @public
- * @experimental
+ * Public result shape describing the `bulkWriteResult` produced by `rewrapManyDataKey`.
  */
 export interface ClientEncryptionRewrapManyDataKeyResult {
   /** The result of rewrapping data keys. If unset, no keys matched the filter. */

package/src/client-side-encryption/kms_options.ts

@@ -88,6 +88,7 @@ export type ClientEncryptionSocketOptions = Pick<
 export type KMSConnectCallback = (options: {
   host: string;
   port: number;
+  /** @deprecated `timeoutMS` has no effect and will be removed in a future release. */
   timeoutMS?: number;
   signal: AbortSignal;
 }) => Promise<Duplex>;

package/src/cmap/wire_protocol/compression.ts

@@ -1,7 +1,7 @@
 import * as zlib from 'zlib';
 
 import { ByteUtils, readInt32LE } from '../../bson';
-import { LEGACY_HELLO_COMMAND } from '../../constants';
+import { LEGACY_HELLO_COMMAND, LEGACY_HELLO_COMMAND_CAMEL_CASE } from '../../constants';
 import { getSnappy, getZstdLibrary, type SnappyLib, type ZStandard } from '../../deps';
 import { MongoDecompressionError, MongoInvalidArgumentError } from '../../error';
 import {
@@ -29,7 +29,9 @@ export type Compressor = (typeof Compressor)[CompressorName];
 export type CompressorName = keyof typeof Compressor;
 
 export const uncompressibleCommands = new Set([
+  'hello',
   LEGACY_HELLO_COMMAND,
+  LEGACY_HELLO_COMMAND_CAMEL_CASE,
   'saslStart',
   'saslContinue',
   'getnonce',

package/src/collection.ts

@@ -56,12 +56,14 @@ import {
 import {
   CreateIndexesOperation,
   type CreateIndexesOptions,
+  type CreateIndexOptions,
   type DropIndexesOptions,
   DropIndexOperation,
   type IndexDescription,
   type IndexDescriptionCompact,
   type IndexDescriptionInfo,
   type IndexInformationOptions,
+  type IndexOptions,
   type IndexSpecification,
   type ListIndexesOptions
 } from './operations/indexes';
@@ -120,8 +122,8 @@ export interface CollectionOptions extends BSONSerializeOptions, WriteConcernOpt
   /** The preferred read preference (ReadPreference.PRIMARY, ReadPreference.PRIMARY_PREFERRED, ReadPreference.SECONDARY, ReadPreference.SECONDARY_PREFERRED, ReadPreference.NEAREST). */
   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;
 }
@@ -275,8 +277,9 @@ export class Collection<TSchema extends Document = Document> {
     this.s.collectionHint = normalizeHintField(v);
   }
 
+  /** @deprecated `timeoutMS` has no effect and will be removed in a future release. */
   public get timeoutMS(): number | undefined {
-    return this.s.options.timeoutMS;
+    return undefined;
   }
 
   /**
@@ -609,7 +612,7 @@ export class Collection<TSchema extends Document = Document> {
    * Creates an index on the db and collection collection.
    *
    * @param indexSpec - The field name or index specification to create an index for
-   * @param options - Optional settings for the command
+   * @param indexOptions - Optional settings for the command
    *
    * @example
    * ```ts
@@ -632,20 +635,55 @@ export class Collection<TSchema extends Document = Document> {
    * // Equivalent to { j: 1, k: -1, l: 2d }
    * await collection.createIndex(['j', ['k', -1], { l: '2d' }])
    * ```
+   * @deprecated Use the three parameter overload, which separates index options from
+   *   command options. This overload will be removed in a future major release.
+   */
+  createIndex(indexSpec: IndexSpecification, options?: CreateIndexesOptions): Promise<string>;
+
+  /**
+   * Creates an index on the db and collection collection.
+   *
+   * Options for the index itself are given in `indexOptions`, and options for the
+   * `createIndexes` command are given separately in `commandOptions`. Unknown fields in
+   * `indexOptions` are passed through to the server for validation rather than being dropped.
+   *
+   * @param keys - The field name or index specification to create an index for
+   * @param indexOptions - Settings for the index, or `undefined` if there are none
+   * @param commandOptions - Settings for the `createIndexes` command, or `undefined` if there are none
    */
+  createIndex(
+    keys: IndexSpecification,
+    indexOptions: IndexOptions | undefined,
+    commandOptions: CreateIndexOptions | undefined
+  ): Promise<string>;
+
   async createIndex(
     indexSpec: IndexSpecification,
-    options?: CreateIndexesOptions
+    indexOptions?: CreateIndexesOptions | IndexOptions,
+    commandOptions?: CreateIndexOptions
   ): Promise<string> {
-    const indexes = await executeOperation(
-      this.client,
-      CreateIndexesOperation.fromIndexSpecification(
-        this,
-        this.collectionName,
-        indexSpec,
-        resolveOptions(this, options)
-      )
-    );
+    // When commandOptions is provided the caller has separated the two kinds of options, so the
+    // index options are forwarded as-is and only the command options inherit from the parent.
+    // Otherwise indexOptions is both, and it inherits from the parent as it always has.
+    const operation =
+      commandOptions == null
+        ? CreateIndexesOperation.fromIndexSpecification(
+            this,
+            this.collectionName,
+            indexSpec,
+            false,
+            resolveOptions(this, indexOptions), // at this point indexOptions is the combined index and command options
+            undefined
+          )
+        : CreateIndexesOperation.fromIndexSpecification(
+            this,
+            this.collectionName,
+            indexSpec,
+            true,
+            indexOptions,
+            resolveOptions(this, commandOptions)
+          );
+    const indexes = await executeOperation(this.client, operation);
 
     return indexes[0];
   }
@@ -659,7 +697,7 @@ export class Collection<TSchema extends Document = Document> {
    * Index specifications are defined {@link https://www.mongodb.com/docs/manual/reference/command/createIndexes/| here}.
    *
    * @param indexSpecs - An array of index specifications to be created
-   * @param options - Optional settings for the command
+   * @param commandOptions - Optional settings for the `createIndexes` command
    *
    * @example
    * ```ts
@@ -681,9 +719,35 @@ export class Collection<TSchema extends Document = Document> {
    * ]);
    * ```
    */
+  createIndexes(
+    indexSpecs: IndexDescription[],
+    commandOptions?: CreateIndexesOptions
+  ): Promise<string[]>;
+
+  /**
+   * Creates multiple indexes in the collection, opting into "pass through" behavior for index
+   * options the driver does not recognise.
+   *
+   * @param indexSpecs - An array of index specifications to be created
+   * @param commandOptions - Optional settings for the `createIndexes` command
+   * @param allowUnknownIndexOptions - When `true`, index options the driver does not recognise are
+   *   sent to the server instead of being dropped, for the server to validate.
+   *
+   * @deprecated Used to opt into "pass through" behavior, where options will be validated by the
+   *   server rather than the driver. In a future release this overload will be removed and the
+   *   default behavior will change from `false` to `true`.
+   */
+  createIndexes(
+    indexSpecs: IndexDescription[],
+    commandOptions: CreateIndexesOptions | undefined,
+    allowUnknownIndexOptions: boolean
+  ): Promise<string[]>;
+
   async createIndexes(
     indexSpecs: IndexDescription[],
-    options?: CreateIndexesOptions
+    commandOptions?: CreateIndexesOptions,
+    // TODO(NODE-7868): Remove allowUnknownIndexOptions with a default behavior of true in a future major version release
+    allowUnknownIndexOptions = false
   ): Promise<string[]> {
     return await executeOperation(
       this.client,
@@ -691,7 +755,9 @@ export class Collection<TSchema extends Document = Document> {
         this,
         this.collectionName,
         indexSpecs,
-        resolveOptions(this, { ...options, maxTimeMS: undefined })
+        // TODO(NODE-7868): Remove allowUnknownIndexOptions with a default behavior of true in a future major version release
+        allowUnknownIndexOptions,
+        resolveOptions(this, { ...commandOptions, maxTimeMS: undefined })
       )
     );
   }
@@ -1105,60 +1171,6 @@ export class Collection<TSchema extends Document = Document> {
    *     expectType<Schema>(change.fullDocument);
    *   });
    * ```
-   *
-   * @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 TLocal - Type of the data being detected by the change stream
@@ -1251,7 +1263,7 @@ export class Collection<TSchema extends Document = Document> {
           ? null
           : indexNameOrOptions;
 
-    return new ListSearchIndexesCursor(this as TODO_NODE_3286, indexName, options);
+    return new ListSearchIndexesCursor(this as TODO_NODE_3286, indexName, { ...options });
   }
 
   /**

package/src/connection_string.ts

@@ -24,19 +24,46 @@ import { resolveRuntimeAdapters } from './runtime_adapters';
 import { ServerMonitoringMode } from './sdam/monitor';
 import type { TagSet } from './sdam/server_description';
 import {
-  checkParentDomainMatch,
   DEFAULT_PK_FACTORY,
+  dnsNameToASCII,
   emitWarning,
   HostAddress,
   isRecord,
+  normalizeDnsName,
   parseInteger,
   setDifference,
-  squashError
+  squashError,
+  verifySrvHost
 } from './utils';
 import { type W, WriteConcern } from './write_concern';
 
 const VALID_TXT_RECORDS = ['authSource', 'replicaSet', 'loadBalanced'];
 
+/** Options that only apply to SRV resolution, and so are invalid with a non-SRV connection string */
+const SRV_ONLY_OPTIONS = [
+  'srvMaxHosts',
+  'srvServiceName',
+  'srvAllowedHostsSuffix',
+  'srvHostValidator'
+] as const;
+
+/** Single labels that srvAllowedHostsSuffix may be, as they are reserved for private or special use */
+const VALID_SINGLE_LABEL_SUFFIXES = new Set([
+  // RFC 6761 special use names
+  'test',
+  'localhost',
+  'invalid',
+  'example',
+  // RFC 6762 multicast DNS
+  'local',
+  // Reserved by ICANN for private use
+  'internal',
+  // Not officially reserved by ICANN, but commonly used privately
+  'corp',
+  'home',
+  'mail'
+]);
+
 const LB_SINGLE_HOST_ERROR = 'loadBalanced option only supported with a single host in the URI';
 const LB_REPLICA_SET_ERROR = 'loadBalanced option not supported with a replicaSet option';
 const LB_DIRECT_CONNECTION_ERROR =
@@ -73,6 +100,9 @@ const resolveTxt = retryDNSTimeoutFor('TXT');
  *
  * @param uri - The connection string to parse
  * @param options - Optional user provided connection string options
+ * @throws MongoAPIError if the SRV lookup returns no hosts, or a returned host fails verification
+ * @throws MongoParseError if the TXT record is invalid, or conflicts with the provided options
+ * @throws Error the error from the DNS lookup, if it fails
  */
 export async function resolveSRVRecord(options: MongoOptions): Promise<HostAddress[]> {
   if (typeof options.srvHost !== 'string') {
@@ -94,11 +124,11 @@ export async function resolveSRVRecord(options: MongoOptions): Promise<HostAddre
     throw new MongoAPIError('No addresses found at host');
   }
 
-  for (const { name } of addresses) {
-    checkParentDomainMatch(name, lookupAddress);
-  }
-
-  const hostAddresses = addresses.map(r => HostAddress.fromString(`${r.name}:${r.port ?? 27017}`));
+  const hostAddresses = addresses.map(({ name, port }) => {
+    const host = normalizeDnsName(name);
+    verifySrvHost(host, lookupAddress, options);
+    return HostAddress.fromString(`${host}:${port ?? 27017}`);
+  });
 
   validateLoadBalancedOptions(hostAddresses, options, true);
 
@@ -294,7 +324,7 @@ export function parseOptions(
       );
     }
 
-    if (!isReadPreferenceTags && values.includes('')) {
+    if (!isReadPreferenceTags && values.includes('') && !isIgnoredOption(key)) {
       throw new MongoAPIError(`URI option "${key}" cannot be specified with no value`);
     }
 
@@ -315,6 +345,12 @@ export function parseOptions(
     );
   }
 
+  if (urlOptions.has('srvHostValidator')) {
+    throw new MongoParseError(
+      'URI cannot contain `srvHostValidator`, it can only be passed to the client'
+    );
+  }
+
   const uriMechanismProperties = urlOptions.get('authMechanismProperties');
   if (uriMechanismProperties) {
     for (const property of uriMechanismProperties) {
@@ -380,12 +416,14 @@ export function parseOptions(
         setOption(mongoOptions, key, descriptor, [DEFAULT_OPTIONS.get(key)]);
       }
     } else {
-      const { deprecated } = descriptor;
+      const { deprecated, ignored } = descriptor;
       if (deprecated) {
         const deprecatedMsg = typeof deprecated === 'string' ? `: ${deprecated}` : '';
         emitWarning(`${key} is a deprecated option${deprecatedMsg}`);
       }
 
+      if (ignored) continue;
+
       setOption(mongoOptions, key, descriptor, values);
     }
   }
@@ -477,6 +515,10 @@ export function parseOptions(
       throw new MongoParseError('Cannot use srvMaxHosts option with replicaSet');
     }
 
+    if (mongoOptions.srvAllowedHostsSuffix != null && mongoOptions.srvHostValidator != null) {
+      throw new MongoParseError('Cannot use srvAllowedHostsSuffix together with srvHostValidator');
+    }
+
     // SRV turns on TLS by default, but users can override and turn it off
     const noUserSpecifiedTLS = !objectOptions.has('tls') && !urlOptions.has('tls');
     const noUserSpecifiedSSL = !objectOptions.has('ssl') && !urlOptions.has('ssl');
@@ -484,15 +526,13 @@ export function parseOptions(
       mongoOptions.tls = true;
     }
   } else {
-    const userSpecifiedSrvOptions =
-      urlOptions.has('srvMaxHosts') ||
-      objectOptions.has('srvMaxHosts') ||
-      urlOptions.has('srvServiceName') ||
-      objectOptions.has('srvServiceName');
+    const userSpecifiedSrvOptions = SRV_ONLY_OPTIONS.filter(
+      option => urlOptions.has(option) || objectOptions.has(option)
+    );
 
-    if (userSpecifiedSrvOptions) {
+    if (userSpecifiedSrvOptions.length > 0) {
       throw new MongoParseError(
-        'Cannot use srvMaxHosts or srvServiceName with a non-srv connection string'
+        `Cannot use ${userSpecifiedSrvOptions.join(', ')} with a non-srv connection string`
       );
     }
   }
@@ -584,6 +624,50 @@ function validateLoadBalancedOptions(
   return;
 }
 
+/**
+ * Validates and normalizes an `srvAllowedHostsSuffix` value, following the steps in the Initial DNS
+ * Seedlist Discovery specification.
+ *
+ * @returns the suffix in lowercase A-label (Punycode) form, beginning with `.`
+ * @throws MongoParseError if the value is not a valid suffix
+ */
+function normalizeSrvAllowedHostsSuffix(value: string): string {
+  // 1. Strip leading and trailing dots
+  const stripped = value.replace(/^\.+|\.+$/g, '');
+  if (stripped === '') {
+    throw new MongoParseError('srvAllowedHostsSuffix must contain at least one domain label');
+  }
+
+  // 2 and 3. Convert to lowercase A-label form, using the WHATWG URL Standard's domain parser, the
+  // same conversion applied to the host names returned by the SRV lookup
+  const suffix = dnsNameToASCII(stripped);
+  if (suffix == null) {
+    throw new MongoParseError(`srvAllowedHostsSuffix "${value}" is not a valid domain name`);
+  }
+
+  // 4. Require at least two labels, unless the value is a reserved single label
+  if (!suffix.includes('.') && !VALID_SINGLE_LABEL_SUFFIXES.has(suffix)) {
+    throw new MongoParseError(
+      `srvAllowedHostsSuffix "${value}" must contain at least two domain labels, or be one of: ${[
+        ...VALID_SINGLE_LABEL_SUFFIXES
+      ].join(', ')}`
+    );
+  }
+
+  // 5. Rejecting public suffixes via the Public Suffix List is a SHOULD that is intentionally not
+  // implemented by the Node Driver. Skipping.
+
+  // 6. Prepend a dot so the suffix only matches whole labels
+  return `.${suffix}`;
+}
+
+/** Ignored options are never validated, since their values have no effect. */
+function isIgnoredOption(key: string): boolean {
+  return Object.entries(OPTIONS).some(
+    ([name, descriptor]) => descriptor.ignored && name.toLowerCase() === key.toLowerCase()
+  );
+}
+
 function setOption(
   mongoOptions: any,
   key: string,
@@ -638,6 +722,8 @@ interface OptionDescriptor {
   default?: any;
 
   deprecated?: boolean | string;
+  /** The option is accepted but has no effect, so it is never stored on the resolved options. */
+  ignored?: boolean;
   /**
    * @param name - the original option name
    * @param options - the options so far for resolution
@@ -1105,10 +1191,40 @@ export const OPTIONS = {
     type: 'string'
   },
   socketTimeoutMS: {
-    // TODO(NODE-6491): deprecated: 'Please use timeoutMS instead',
     default: 0,
     type: 'uint'
   },
+  srvAllowedHostsSuffix: {
+    transform({ values: [value] }): string {
+      if (typeof value !== 'string') {
+        throw new MongoParseError('srvAllowedHostsSuffix must be a string');
+      }
+      return normalizeSrvAllowedHostsSuffix(value);
+    }
+  },
+  srvHostValidator: {
+    transform({ values: [value] }): (host: string) => boolean {
+      if (typeof value !== 'function') {
+        throw new MongoParseError('srvHostValidator must be a function');
+      }
+      // Wrap the validator so that every caller gets a boolean or a MongoAPIError
+      return (host: string): boolean => {
+        let isValid: unknown;
+        try {
+          isValid = value(host);
+        } catch (error) {
+          throw new MongoAPIError('srvHostValidator threw an error', { cause: error });
+        }
+        // A Promise (e.g. from an async validator) is truthy, so accepting it would silently allow every host
+        if (typeof isValid !== 'boolean') {
+          throw new MongoAPIError(
+            `srvHostValidator must return a boolean, received ${typeof isValid}`
+          );
+        }
+        return isValid;
+      };
+    }
+  },
   srvMaxHosts: {
     type: 'uint',
     default: 0
@@ -1122,7 +1238,8 @@ export const OPTIONS = {
     type: 'boolean'
   },
   timeoutMS: {
-    type: 'uint'
+    deprecated: 'timeoutMS has no effect and will be removed in a future release',
+    ignored: true
   },
   tls: {
     type: 'boolean'
@@ -1176,7 +1293,6 @@ export const OPTIONS = {
     }
   },
   waitQueueTimeoutMS: {
-    // TODO(NODE-6491): deprecated: 'Please use timeoutMS instead',
     default: 0,
     type: 'uint'
   },