mongodb 6.8.0-dev.20240905.sha.65e0e15c → 6.8.1

package/src/cmap/auth/mongodb_oidc/callback_workflow.ts

@@ -160,9 +160,9 @@ export abstract class CallbackWorkflow implements Workflow {
       // previous lock, only the current callback's value would get returned.
       await lock;
       lock = lock
-
+        // eslint-disable-next-line github/no-then
         .catch(() => null)
-
+        // eslint-disable-next-line github/no-then
         .then(async () => {
           const difference = Date.now() - this.lastExecutionTime;
           if (difference <= THROTTLE_MS) {

package/src/cmap/auth/mongodb_oidc/machine_workflow.ts

@@ -115,9 +115,9 @@ export abstract class MachineWorkflow implements Workflow {
       // previous lock, only the current callback's value would get returned.
       await lock;
       lock = lock
-
+        // eslint-disable-next-line github/no-then
         .catch(() => null)
-
+        // eslint-disable-next-line github/no-then
         .then(async () => {
           const difference = Date.now() - this.lastExecutionTime;
           if (difference <= THROTTLE_MS) {

package/src/cmap/commands.ts

@@ -30,8 +30,6 @@ const QUERY_FAILURE = 2;
 const SHARD_CONFIG_STALE = 4;
 const AWAIT_CAPABLE = 8;
 
-const encodeUTF8Into = BSON.BSON.onDemand.ByteUtils.encodeUTF8Into;
-
 /** @internal */
 export type WriteProtocolMessageType = OpQueryRequest | OpMsgRequest;
 
@@ -75,11 +73,7 @@ export class OpQueryRequest {
   exhaust: boolean;
   partial: boolean;
 
-  constructor(
-    public databaseName: string,
-    public query: Document,
-    options: OpQueryOptions
-  ) {
+  constructor(public databaseName: string, public query: Document, options: OpQueryOptions) {
     // Basic options needed to be passed in
     // TODO(NODE-3483): Replace with MongoCommandError
     const ns = `${databaseName}.$cmd`;
@@ -417,15 +411,6 @@ export interface OpMsgOptions {
   readPreference: ReadPreference;
 }
 
-/** @internal */
-export class DocumentSequence {
-  documents: Document[];
-
-  constructor(documents: Document[]) {
-    this.documents = documents;
-  }
-}
-
 /** @internal */
 export class OpMsgRequest {
   requestId: number;
@@ -495,7 +480,7 @@ export class OpMsgRequest {
 
     let totalLength = header.length;
     const command = this.command;
-    totalLength += this.makeSections(buffers, command);
+    totalLength += this.makeDocumentSegment(buffers, command);
 
     header.writeInt32LE(totalLength, 0); // messageLength
     header.writeInt32LE(this.requestId, 4); // requestID
@@ -505,65 +490,15 @@ export class OpMsgRequest {
     return buffers;
   }
 
-  /**
-   * Add the sections to the OP_MSG request's buffers and returns the length.
-   */
-  makeSections(buffers: Uint8Array[], document: Document): number {
-    const sequencesBuffer = this.extractDocumentSequences(document);
-    const payloadTypeBuffer = Buffer.allocUnsafe(1);
+  makeDocumentSegment(buffers: Uint8Array[], document: Document): number {
+    const payloadTypeBuffer = Buffer.alloc(1);
     payloadTypeBuffer[0] = 0;
 
     const documentBuffer = this.serializeBson(document);
-    // First section, type 0
     buffers.push(payloadTypeBuffer);
     buffers.push(documentBuffer);
-    // Subsequent sections, type 1
-    buffers.push(sequencesBuffer);
-
-    return payloadTypeBuffer.length + documentBuffer.length + sequencesBuffer.length;
-  }
 
-  /**
-   * Extracts the document sequences from the command document and returns
-   * a buffer to be added as multiple sections after the initial type 0
-   * section in the message.
-   */
-  extractDocumentSequences(document: Document): Uint8Array {
-    // Pull out any field in the command document that's value is a document sequence.
-    const chunks = [];
-    for (const [key, value] of Object.entries(document)) {
-      if (value instanceof DocumentSequence) {
-        // Document sequences starts with type 1 at the first byte.
-        const buffer = Buffer.allocUnsafe(1 + 4 + key.length);
-        buffer[0] = 1;
-        // Third part is the field name at offset 5.
-        encodeUTF8Into(buffer, key, 5);
-        chunks.push(buffer);
-        // Fourth part are the documents' bytes.
-        let docsLength = 0;
-        for (const doc of value.documents) {
-          const docBson = this.serializeBson(doc);
-          docsLength += docBson.length;
-          chunks.push(docBson);
-        }
-        // Second part of the sequence is the length at offset 1;
-        buffer.writeInt32LE(key.length + docsLength, 1);
-        // Why are we removing the field from the command? This is because it needs to be
-        // removed in the OP_MSG request first section, and DocumentSequence is not a
-        // BSON type and is specific to the MongoDB wire protocol so there's nothing
-        // our BSON serializer can do about this. Since DocumentSequence is not exposed
-        // in the public API and only used internally, we are never mutating an original
-        // command provided by the user, just our own, and it's cheaper to delete from
-        // our own command than copying it.
-        delete document[key];
-      }
-    }
-    if (chunks.length > 0) {
-      return Buffer.concat(chunks);
-    }
-    // If we have no document sequences we return an empty buffer for nothing to add
-    // to the payload.
-    return Buffer.alloc(0);
+    return payloadTypeBuffer.length + documentBuffer.length;
   }
 
   serializeBson(document: Document): Uint8Array {

package/src/cmap/connect.ts

@@ -164,7 +164,7 @@ export async function performInitialHandshake(
     } catch (error) {
       if (error instanceof MongoError) {
         error.addErrorLabel(MongoErrorLabel.HandshakeError);
-        if (needsRetryableWriteLabel(error, response.maxWireVersion, conn.description.type)) {
+        if (needsRetryableWriteLabel(error, response.maxWireVersion)) {
           error.addErrorLabel(MongoErrorLabel.RetryableWriteError);
         }
       }
@@ -269,8 +269,6 @@ export const LEGAL_TLS_SOCKET_OPTIONS = [
 
 /** @public */
 export const LEGAL_TCP_SOCKET_OPTIONS = [
-  'autoSelectFamily',
-  'autoSelectFamilyAttemptTimeout',
   'family',
   'hints',
   'localAddress',

package/src/cmap/connection.ts

@@ -1,3 +1,4 @@
+import { type DeserializeOptions } from 'bson';
 import { type Readable, Transform, type TransformCallback } from 'stream';
 import { clearTimeout, setTimeout } from 'timers';
 
@@ -332,7 +333,7 @@ export class Connection extends TypedEventEmitter<ConnectionEvents> {
 
     this.socket.destroy();
     this.error = error;
-
+    // eslint-disable-next-line github/no-then
     this.dataEvents?.throw(error).then(undefined, squashError);
     this.closed = true;
     this.emit(Connection.CLOSE);
@@ -487,7 +488,7 @@ export class Connection extends TypedEventEmitter<ConnectionEvents> {
 
     // If `documentsReturnedIn` not set or raw is not enabled, use input bson options
     // Otherwise, support raw flag. Raw only works for cursors that hardcode firstBatch/nextBatch fields
-    const bsonOptions =
+    const bsonOptions: DeserializeOptions =
       options.documentsReturnedIn == null || !options.raw
         ? options
         : {
@@ -602,7 +603,7 @@ export class Connection extends TypedEventEmitter<ConnectionEvents> {
       }
       throw new MongoUnexpectedServerResponseError('Server ended moreToCome unexpectedly');
     };
-
+    // eslint-disable-next-line github/no-then
     exhaustLoop().then(undefined, replyListener);
   }
 

package/src/cmap/connection_pool.ts

@@ -27,7 +27,7 @@ import {
 import { CancellationToken, TypedEventEmitter } from '../mongo_types';
 import type { Server } from '../sdam/server';
 import { Timeout, TimeoutError } from '../timeout';
-import { type Callback, List, makeCounter, now, promiseWithResolvers } from '../utils';
+import { type Callback, List, makeCounter, promiseWithResolvers } from '../utils';
 import { connect } from './connect';
 import { Connection, type ConnectionEvents, type ConnectionOptions } from './connection';
 import {
@@ -104,7 +104,6 @@ export interface WaitQueueMember {
   reject: (err: AnyError) => void;
   timeout: Timeout;
   [kCancelled]?: boolean;
-  checkoutTime: number;
 }
 
 /** @internal */
@@ -356,7 +355,6 @@ export class ConnectionPool extends TypedEventEmitter<ConnectionPoolEvents> {
    * explicitly destroyed by the new owner.
    */
   async checkOut(): Promise<Connection> {
-    const checkoutTime = now();
     this.emitAndLog(
       ConnectionPool.CONNECTION_CHECK_OUT_STARTED,
       new ConnectionCheckOutStartedEvent(this)
@@ -371,8 +369,7 @@ export class ConnectionPool extends TypedEventEmitter<ConnectionPoolEvents> {
     const waitQueueMember: WaitQueueMember = {
       resolve,
       reject,
-      timeout,
-      checkoutTime
+      timeout
     };
 
     this[kWaitQueue].push(waitQueueMember);
@@ -388,7 +385,7 @@ export class ConnectionPool extends TypedEventEmitter<ConnectionPoolEvents> {
 
         this.emitAndLog(
           ConnectionPool.CONNECTION_CHECK_OUT_FAILED,
-          new ConnectionCheckOutFailedEvent(this, 'timeout', waitQueueMember.checkoutTime)
+          new ConnectionCheckOutFailedEvent(this, 'timeout')
         );
         const timeoutError = new WaitQueueTimeoutError(
           this.loadBalanced
@@ -632,12 +629,12 @@ export class ConnectionPool extends TypedEventEmitter<ConnectionPoolEvents> {
 
     this[kPending]++;
     // This is our version of a "virtual" no-I/O connection as the spec requires
-    const connectionCreatedTime = now();
     this.emitAndLog(
       ConnectionPool.CONNECTION_CREATED,
       new ConnectionCreatedEvent(this, { id: connectOptions.id })
     );
 
+    // eslint-disable-next-line github/no-then
     connect(connectOptions).then(
       connection => {
         // The pool might have closed since we started trying to create a connection
@@ -673,7 +670,7 @@ export class ConnectionPool extends TypedEventEmitter<ConnectionPoolEvents> {
         connection.markAvailable();
         this.emitAndLog(
           ConnectionPool.CONNECTION_READY,
-          new ConnectionReadyEvent(this, connection, connectionCreatedTime)
+          new ConnectionReadyEvent(this, connection)
         );
 
         this[kPending]--;
@@ -762,7 +759,7 @@ export class ConnectionPool extends TypedEventEmitter<ConnectionPoolEvents> {
         const error = this.closed ? new PoolClosedError(this) : new PoolClearedError(this);
         this.emitAndLog(
           ConnectionPool.CONNECTION_CHECK_OUT_FAILED,
-          new ConnectionCheckOutFailedEvent(this, reason, waitQueueMember.checkoutTime, error)
+          new ConnectionCheckOutFailedEvent(this, reason, error)
         );
         waitQueueMember.timeout.clear();
         this[kWaitQueue].shift();
@@ -783,7 +780,7 @@ export class ConnectionPool extends TypedEventEmitter<ConnectionPoolEvents> {
         this[kCheckedOut].add(connection);
         this.emitAndLog(
           ConnectionPool.CONNECTION_CHECKED_OUT,
-          new ConnectionCheckedOutEvent(this, connection, waitQueueMember.checkoutTime)
+          new ConnectionCheckedOutEvent(this, connection)
         );
         waitQueueMember.timeout.clear();
 
@@ -812,19 +809,14 @@ export class ConnectionPool extends TypedEventEmitter<ConnectionPoolEvents> {
             this.emitAndLog(
               ConnectionPool.CONNECTION_CHECK_OUT_FAILED,
               // TODO(NODE-5192): Remove this cast
-              new ConnectionCheckOutFailedEvent(
-                this,
-                'connectionError',
-                waitQueueMember.checkoutTime,
-                err as MongoError
-              )
+              new ConnectionCheckOutFailedEvent(this, 'connectionError', err as MongoError)
             );
             waitQueueMember.reject(err);
           } else if (connection) {
             this[kCheckedOut].add(connection);
             this.emitAndLog(
               ConnectionPool.CONNECTION_CHECKED_OUT,
-              new ConnectionCheckedOutEvent(this, connection, waitQueueMember.checkoutTime)
+              new ConnectionCheckedOutEvent(this, connection)
             );
             waitQueueMember.resolve(connection);
           }

package/src/cmap/connection_pool_events.ts

@@ -13,7 +13,6 @@ import {
   CONNECTION_READY
 } from '../constants';
 import type { MongoError } from '../error';
-import { now } from '../utils';
 import type { Connection } from './connection';
 import type { ConnectionPool, ConnectionPoolOptions } from './connection_pool';
 
@@ -127,25 +126,12 @@ export class ConnectionCreatedEvent extends ConnectionPoolMonitoringEvent {
 export class ConnectionReadyEvent extends ConnectionPoolMonitoringEvent {
   /** The id of the connection */
   connectionId: number | '<monitor>';
-  /**
-   * The time it took to establish the connection.
-   * In accordance with the definition of establishment of a connection
-   * specified by `ConnectionPoolOptions.maxConnecting`,
-   * it is the time elapsed between emitting a `ConnectionCreatedEvent`
-   * and emitting this event as part of the same checking out.
-   *
-   * Naturally, when establishing a connection is part of checking out,
-   * this duration is not greater than
-   * `ConnectionCheckedOutEvent.duration`.
-   */
-  durationMS: number;
   /** @internal */
   name = CONNECTION_READY;
 
   /** @internal */
-  constructor(pool: ConnectionPool, connection: Connection, connectionCreatedEventTime: number) {
+  constructor(pool: ConnectionPool, connection: Connection) {
     super(pool);
-    this.durationMS = now() - connectionCreatedEventTime;
     this.connectionId = connection.id;
   }
 }
@@ -208,23 +194,14 @@ export class ConnectionCheckOutFailedEvent extends ConnectionPoolMonitoringEvent
   error?: MongoError;
   /** @internal */
   name = CONNECTION_CHECK_OUT_FAILED;
-  /**
-   * The time it took to check out the connection.
-   * More specifically, the time elapsed between
-   * emitting a `ConnectionCheckOutStartedEvent`
-   * and emitting this event as part of the same check out.
-   */
-  durationMS: number;
 
   /** @internal */
   constructor(
     pool: ConnectionPool,
     reason: 'poolClosed' | 'timeout' | 'connectionError',
-    checkoutTime: number,
     error?: MongoError
   ) {
     super(pool);
-    this.durationMS = now() - checkoutTime;
     this.reason = reason;
     this.error = error;
   }
@@ -240,19 +217,10 @@ export class ConnectionCheckedOutEvent extends ConnectionPoolMonitoringEvent {
   connectionId: number | '<monitor>';
   /** @internal */
   name = CONNECTION_CHECKED_OUT;
-  /**
-   * The time it took to check out the connection.
-   * More specifically, the time elapsed between
-   * emitting a `ConnectionCheckOutStartedEvent`
-   * and emitting this event as part of the same checking out.
-   *
-   */
-  durationMS: number;
 
   /** @internal */
-  constructor(pool: ConnectionPool, connection: Connection, checkoutTime: number) {
+  constructor(pool: ConnectionPool, connection: Connection) {
     super(pool);
-    this.durationMS = now() - checkoutTime;
     this.connectionId = connection.id;
   }
 }

package/src/cmap/handshake/client_metadata.ts

@@ -6,7 +6,7 @@ import { MongoInvalidArgumentError } from '../../error';
 import type { MongoOptions } from '../../mongo_client';
 import { fileIsAccessible } from '../../utils';
 
-// eslint-disable-next-line @typescript-eslint/no-require-imports
+// eslint-disable-next-line @typescript-eslint/no-var-requires
 const NODE_DRIVER_VERSION = require('../../../package.json').version;
 
 /**

package/src/cmap/wire_protocol/constants.ts

@@ -1,7 +1,7 @@
 export const MIN_SUPPORTED_SERVER_VERSION = '3.6';
-export const MAX_SUPPORTED_SERVER_VERSION = '8.0';
+export const MAX_SUPPORTED_SERVER_VERSION = '7.0';
 export const MIN_SUPPORTED_WIRE_VERSION = 6;
-export const MAX_SUPPORTED_WIRE_VERSION = 25;
+export const MAX_SUPPORTED_WIRE_VERSION = 21;
 export const MIN_SUPPORTED_QE_WIRE_VERSION = 21;
 export const MIN_SUPPORTED_QE_SERVER_VERSION = '7.0';
 export const OP_REPLY = 1;

package/src/cmap/wire_protocol/on_demand/document.ts

@@ -1,8 +1,9 @@
+import { type DeserializeOptions } from 'bson';
+
 import {
   Binary,
   type BSONElement,
   BSONError,
-  type BSONSerializeOptions,
   BSONType,
   deserialize,
   getBigInt64LE,
@@ -10,7 +11,6 @@ import {
   getInt32LE,
   ObjectId,
   parseToElementsToArray,
-  pluckBSONSerializeOptions,
   Timestamp,
   toUTF8
 } from '../../../bson';
@@ -44,6 +44,14 @@ export type JSTypeOf = {
 /** @internal */
 type CachedBSONElement = { element: BSONElement; value: any | undefined };
 
+/**
+ * @internal
+ *
+ * Options for `OnDemandDocument.toObject()`. Validation is required to ensure
+ * that callers provide utf8 validation options. */
+export type OnDemandDocumentDeserializeOptions = Omit<DeserializeOptions, 'validation'> &
+  Required<Pick<DeserializeOptions, 'validation'>>;
+
 /** @internal */
 export class OnDemandDocument {
   /**
@@ -330,24 +338,12 @@ export class OnDemandDocument {
    * Deserialize this object, DOES NOT cache result so avoid multiple invocations
    * @param options - BSON deserialization options
    */
-  public toObject(options?: BSONSerializeOptions): Record<string, any> {
-    const exactBSONOptions = {
-      ...pluckBSONSerializeOptions(options ?? {}),
-      validation: this.parseBsonSerializationOptions(options),
+  public toObject(options?: OnDemandDocumentDeserializeOptions): Record<string, any> {
+    return deserialize(this.bson, {
+      ...options,
       index: this.offset,
       allowObjectSmallerThanBufferSize: true
-    };
-    return deserialize(this.bson, exactBSONOptions);
-  }
-
-  private parseBsonSerializationOptions(options?: { enableUtf8Validation?: boolean }): {
-    utf8: { writeErrors: false } | false;
-  } {
-    const enableUtf8Validation = options?.enableUtf8Validation;
-    if (enableUtf8Validation === false) {
-      return { utf8: false };
-    }
-    return { utf8: { writeErrors: false } };
+    });
   }
 
   /** Returns this document's bytes only */

package/src/cmap/wire_protocol/responses.ts

@@ -1,3 +1,5 @@
+import { type DeserializeOptions } from 'bson';
+
 import {
   type BSONElement,
   type BSONSerializeOptions,
@@ -5,12 +7,18 @@ import {
   type Document,
   Long,
   parseToElementsToArray,
+  parseUtf8ValidationOption,
+  pluckBSONSerializeOptions,
   type Timestamp
 } from '../../bson';
 import { MongoUnexpectedServerResponseError } from '../../error';
 import { type ClusterTime } from '../../sdam/common';
 import { decorateDecryptionResult, ns } from '../../utils';
-import { type JSTypeOf, OnDemandDocument } from './on_demand/document';
+import {
+  type JSTypeOf,
+  OnDemandDocument,
+  type OnDemandDocumentDeserializeOptions
+} from './on_demand/document';
 
 // eslint-disable-next-line no-restricted-syntax
 const enum BSONElementOffset {
@@ -112,7 +120,8 @@ export class MongoDBResponse extends OnDemandDocument {
       this.get('recoveryToken', BSONType.object)?.toObject({
         promoteValues: false,
         promoteLongs: false,
-        promoteBuffers: false
+        promoteBuffers: false,
+        validation: { utf8: true }
       }) ?? null
     );
   }
@@ -165,6 +174,14 @@ export class MongoDBResponse extends OnDemandDocument {
     }
     return this.clusterTime ?? null;
   }
+
+  public override toObject(options?: BSONSerializeOptions): Record<string, any> {
+    const exactBSONOptions = {
+      ...pluckBSONSerializeOptions(options ?? {}),
+      validation: parseUtf8ValidationOption(options)
+    };
+    return super.toObject(exactBSONOptions);
+  }
 }
 
 /** @internal */
@@ -248,12 +265,13 @@ export class CursorResponse extends MongoDBResponse {
       this.cursor.get('postBatchResumeToken', BSONType.object)?.toObject({
         promoteValues: false,
         promoteLongs: false,
-        promoteBuffers: false
+        promoteBuffers: false,
+        validation: { utf8: true }
       }) ?? null
     );
   }
 
-  public shift(options?: BSONSerializeOptions): any {
+  public shift(options: OnDemandDocumentDeserializeOptions): any {
     if (this.iterated >= this.batchSize) {
       return null;
     }
@@ -305,7 +323,7 @@ export class ExplainedCursorResponse extends CursorResponse {
     return this._length;
   }
 
-  override shift(options?: BSONSerializeOptions | undefined) {
+  override shift(options?: DeserializeOptions) {
     if (this._length === 0) return null;
     this._length -= 1;
     return this.toObject(options);

package/src/cmap/wire_protocol/shared.ts

@@ -1,5 +1,6 @@
 import { MongoInvalidArgumentError } from '../../error';
-import { ReadPreference, type ReadPreferenceLike } from '../../read_preference';
+import type { ReadPreferenceLike } from '../../read_preference';
+import { ReadPreference } from '../../read_preference';
 import { ServerType } from '../../sdam/common';
 import type { Server } from '../../sdam/server';
 import type { ServerDescription } from '../../sdam/server_description';

package/src/collection.ts

@@ -47,18 +47,17 @@ import {
   FindOneAndUpdateOperation,
   type FindOneAndUpdateOptions
 } from './operations/find_and_modify';
-import {
-  CreateIndexesOperation,
-  type CreateIndexesOptions,
-  type DropIndexesOptions,
-  DropIndexOperation,
-  type IndexDescription,
-  type IndexDescriptionCompact,
-  type IndexDescriptionInfo,
-  type IndexInformationOptions,
-  type IndexSpecification,
-  type ListIndexesOptions
+import type {
+  CreateIndexesOptions,
+  DropIndexesOptions,
+  IndexDescription,
+  IndexDescriptionCompact,
+  IndexDescriptionInfo,
+  IndexInformationOptions,
+  IndexSpecification,
+  ListIndexesOptions
 } from './operations/indexes';
+import { CreateIndexesOperation, DropIndexOperation } from './operations/indexes';
 import {
   InsertManyOperation,
   type InsertManyResult,
@@ -293,7 +292,7 @@ export class Collection<TSchema extends Document = Document> {
    * @param options - Optional settings for the command
    */
   async insertMany(
-    docs: ReadonlyArray<OptionalUnlessRequiredId<TSchema>>,
+    docs: OptionalUnlessRequiredId<TSchema>[],
     options?: BulkWriteOptions
   ): Promise<InsertManyResult<TSchema>> {
     return await executeOperation(
@@ -326,7 +325,7 @@ export class Collection<TSchema extends Document = Document> {
    * @throws MongoDriverError if operations is not an array
    */
   async bulkWrite(
-    operations: ReadonlyArray<AnyBulkWriteOperation<TSchema>>,
+    operations: AnyBulkWriteOperation<TSchema>[],
     options?: BulkWriteOptions
   ): Promise<BulkWriteResult> {
     if (!Array.isArray(operations)) {
@@ -337,7 +336,7 @@ export class Collection<TSchema extends Document = Document> {
       this.client,
       new BulkWriteOperation(
         this as TODO_NODE_3286,
-        operations,
+        operations as TODO_NODE_3286,
         resolveOptions(this, options ?? { ordered: true })
       )
     );
@@ -1122,8 +1121,8 @@ export class Collection<TSchema extends Document = Document> {
       indexNameOrOptions == null
         ? null
         : typeof indexNameOrOptions === 'object'
-          ? null
-          : indexNameOrOptions;
+        ? null
+        : indexNameOrOptions;
 
     return new ListSearchIndexesCursor(this as TODO_NODE_3286, indexName, options);
   }

package/src/connection_string.ts

@@ -73,7 +73,7 @@ export async function resolveSRVRecord(options: MongoOptions): Promise<HostAddre
   // the SRV record is resolved before starting a second DNS query.
   const lookupAddress = options.srvHost;
   const txtResolutionPromise = dns.promises.resolveTxt(lookupAddress);
-
+  // eslint-disable-next-line github/no-then
   txtResolutionPromise.then(undefined, squashError); // rejections will be handled later
 
   // Resolve the SRV record and use the result as the list of hosts to connect to.
@@ -552,6 +552,7 @@ export function parseOptions(
 
   mongoOptions.metadata = makeClientMetadata(mongoOptions);
 
+  // eslint-disable-next-line github/no-then
   mongoOptions.extendedMetadata = addContainerMetadata(mongoOptions.metadata).then(
     undefined,
     squashError
@@ -739,13 +740,6 @@ export const OPTIONS = {
   autoEncryption: {
     type: 'record'
   },
-  autoSelectFamily: {
-    type: 'boolean',
-    default: true
-  },
-  autoSelectFamilyAttemptTimeout: {
-    type: 'uint'
-  },
   bsonRegExp: {
     type: 'boolean'
   },

package/src/constants.ts

@@ -1,4 +1,3 @@
-/* eslint-disable @typescript-eslint/no-unnecessary-type-assertion */
 export const SYSTEM_NAMESPACE_COLLECTION = 'system.namespaces';
 export const SYSTEM_INDEX_COLLECTION = 'system.indexes';
 export const SYSTEM_PROFILE_COLLECTION = 'system.profile';