mongodb 6.20.0-dev.20251106.sha.696664cb → 6.21.0

package/src/cursor/abstract_cursor.ts

@@ -1,4 +1,4 @@
-import { Readable } from 'stream';
+import { Readable, Transform } from 'stream';
 
 import { type BSONSerializeOptions, type Document, Long, pluckBSONSerializeOptions } from '../bson';
 import { type OnDemandDocumentDeserializeOptions } from '../cmap/wire_protocol/on_demand/document';
@@ -18,6 +18,7 @@ import { GetMoreOperation } from '../operations/get_more';
 import { KillCursorsOperation } from '../operations/kill_cursors';
 import { ReadConcern, type ReadConcernLike } from '../read_concern';
 import { ReadPreference, type ReadPreferenceLike } from '../read_preference';
+import { type AsyncDisposable, configureResourceManagement } from '../resource_management';
 import type { Server } from '../sdam/server';
 import { type ClientSession, maybeClearPinnedConnection } from '../sessions';
 import { type CSOTTimeoutContext, type Timeout, TimeoutContext } from '../timeout';
@@ -58,6 +59,15 @@ export const CURSOR_FLAGS = [
   'partial'
 ] as const;
 
+/**
+ * @public
+ * @deprecated Will be removed in the next major version
+ */
+export interface CursorStreamOptions {
+  /** @deprecated Will be removed in the next major version */
+  transform?(this: void, doc: Document): Document;
+}
+
 /** @public */
 export type CursorFlag = (typeof CURSOR_FLAGS)[number];
 
@@ -430,10 +440,13 @@ export abstract class AbstractCursor<
   }
 
   /**
+   * @beta
    * @experimental
    * An alias for {@link AbstractCursor.close|AbstractCursor.close()}.
    */
-  async [Symbol.asyncDispose]() {
+  declare [Symbol.asyncDispose]: () => Promise<void>;
+  /** @internal */
+  async asyncDispose() {
     await this.close();
   }
 
@@ -513,7 +526,7 @@ export abstract class AbstractCursor<
     }
   }
 
-  stream(): Readable & AsyncIterable<TSchema> {
+  stream(options?: CursorStreamOptions): Readable & AsyncIterable<TSchema> {
     const readable = new ReadableCursorStream(this);
     const abortListener = addAbortListener(this.signal, function () {
       readable.destroy(this.reason);
@@ -522,6 +535,31 @@ export abstract class AbstractCursor<
       abortListener?.[kDispose]();
     });
 
+    if (options?.transform) {
+      const transform = options.transform;
+
+      const transformedStream = readable.pipe(
+        new Transform({
+          objectMode: true,
+          highWaterMark: 1,
+          transform(chunk, _, callback) {
+            try {
+              const transformed = transform(chunk);
+              callback(undefined, transformed);
+            } catch (err) {
+              callback(err);
+            }
+          }
+        })
+      );
+
+      // Bubble errors to transformed stream, because otherwise no way
+      // to handle this error.
+      readable.on('error', err => transformedStream.emit('error', err));
+
+      return transformedStream;
+    }
+
     return readable;
   }
 
@@ -666,11 +704,7 @@ export abstract class AbstractCursor<
           array.push(await this.transformDocument(doc));
         }
       } else {
-        // Note: previous versions of this logic used `array.push(...)`, which adds each item
-        // to the callstack.  For large arrays, this can exceed the maximum call size.
-        for (const doc of docs) {
-          array.push(doc);
-        }
+        array.push(...docs);
       }
     }
     return array;
@@ -862,7 +896,7 @@ export abstract class AbstractCursor<
   ): Promise<InitialCursorResponse>;
 
   /** @internal */
-  async getMore(): Promise<CursorResponse> {
+  async getMore(batchSize: number): Promise<CursorResponse> {
     if (this.cursorId == null) {
       throw new MongoRuntimeError(
         'Unexpected null cursor id. A cursor creating command should have set this'
@@ -879,10 +913,11 @@ export abstract class AbstractCursor<
         'Unexpected null session. A cursor creating command should have set this'
       );
     }
+
     const getMoreOptions = {
       ...this.cursorOptions,
       session: this.cursorSession,
-      batchSize: this.cursorOptions.batchSize
+      batchSize
     };
 
     const getMoreOperation = new GetMoreOperation(
@@ -955,11 +990,14 @@ export abstract class AbstractCursor<
       await this.cursorInit();
       // If the cursor died or returned documents, return
       if ((this.documents?.length ?? 0) !== 0 || this.isDead) return;
+      // Otherwise, run a getMore
     }
 
-    // Otherwise, run a getMore
+    // otherwise need to call getMore
+    const batchSize = this.cursorOptions.batchSize || 1000;
+
     try {
-      const response = await this.getMore();
+      const response = await this.getMore(batchSize);
       this.cursorId = response.id;
       this.documents = response;
     } catch (error) {
@@ -1188,6 +1226,8 @@ class ReadableCursorStream extends Readable {
   }
 }
 
+configureResourceManagement(AbstractCursor.prototype);
+
 /**
  * @internal
  * The cursor timeout context is a wrapper around a timeout context

package/src/cursor/change_stream_cursor.ts

@@ -158,8 +158,8 @@ export class ChangeStreamCursor<
     return { server, session, response };
   }
 
-  override async getMore(): Promise<CursorResponse> {
-    const response = await super.getMore();
+  override async getMore(batchSize: number): Promise<CursorResponse> {
+    const response = await super.getMore(batchSize);
 
     this.maxWireVersion = maxWireVersion(this.server);
     this._processBatch(response);

package/src/cursor/find_cursor.ts

@@ -16,7 +16,7 @@ import { FindOperation, type FindOptions } from '../operations/find';
 import type { Hint } from '../operations/operation';
 import type { ClientSession } from '../sessions';
 import { formatSort, type Sort, type SortDirection } from '../sort';
-import { emitWarningOnce, mergeOptions, type MongoDBNamespace, noop, squashError } from '../utils';
+import { emitWarningOnce, mergeOptions, type MongoDBNamespace, squashError } from '../utils';
 import { type InitialCursorResponse } from './abstract_cursor';
 import { ExplainableCursor } from './explainable_cursor';
 
@@ -98,50 +98,37 @@ export class FindCursor<TSchema = any> extends ExplainableCursor<TSchema> {
   }
 
   /** @internal */
-  override async getMore(): Promise<CursorResponse> {
+  override async getMore(batchSize: number): Promise<CursorResponse> {
     const numReturned = this.numReturned;
-    const limit = this.findOptions.limit ?? Infinity;
-    const remaining = limit - numReturned;
-
-    if (numReturned === limit && !this.id?.isZero()) {
-      // this is an optimization for the special case of a limit for a find command to avoid an
-      // extra getMore when the limit has been reached and the limit is a multiple of the batchSize.
-      // This is a consequence of the new query engine in 5.0 having no knowledge of the limit as it
-      // produces results for the find command.  Once a batch is filled up, it is returned and only
-      // on the subsequent getMore will the query framework consider the limit, determine the cursor
-      // is exhausted and return a cursorId of zero.
-      // instead, if we determine there are no more documents to request from the server, we preemptively
-      // close the cursor
-      try {
-        await this.close();
-      } catch (error) {
-        squashError(error);
+    if (numReturned) {
+      // TODO(DRIVERS-1448): Remove logic to enforce `limit` in the driver
+      const limit = this.findOptions.limit;
+      batchSize =
+        limit && limit > 0 && numReturned + batchSize > limit ? limit - numReturned : batchSize;
+
+      if (batchSize <= 0) {
+        try {
+          await this.close();
+        } catch (error) {
+          squashError(error);
+          // this is an optimization for the special case of a limit for a find command to avoid an
+          // extra getMore when the limit has been reached and the limit is a multiple of the batchSize.
+          // This is a consequence of the new query engine in 5.0 having no knowledge of the limit as it
+          // produces results for the find command.  Once a batch is filled up, it is returned and only
+          // on the subsequent getMore will the query framework consider the limit, determine the cursor
+          // is exhausted and return a cursorId of zero.
+          // instead, if we determine there are no more documents to request from the server, we preemptively
+          // close the cursor
+        }
+        return CursorResponse.emptyGetMore;
       }
-      return CursorResponse.emptyGetMore;
-    }
-
-    // TODO(DRIVERS-1448): Remove logic to enforce `limit` in the driver
-    let cleanup: () => void = noop;
-    const { batchSize } = this.cursorOptions;
-    if (batchSize != null && batchSize > remaining) {
-      this.cursorOptions.batchSize = remaining;
-
-      // After executing the final getMore, re-assign the batchSize back to its original value so that
-      // if the cursor is rewound and executed, the batchSize is still correct.
-      cleanup = () => {
-        this.cursorOptions.batchSize = batchSize;
-      };
     }
 
-    try {
-      const response = await super.getMore();
+    const response = await super.getMore(batchSize);
+    // TODO: wrap this in some logic to prevent it from happening if we don't need this support
+    this.numReturned = this.numReturned + response.batchSize;
 
-      this.numReturned = this.numReturned + response.batchSize;
-
-      return response;
-    } finally {
-      cleanup?.();
-    }
+    return response;
   }
 
   /**

package/src/cursor/run_command_cursor.ts

@@ -159,7 +159,7 @@ export class RunCommandCursor extends AbstractCursor {
   }
 
   /** @internal */
-  override async getMore(): Promise<CursorResponse> {
+  override async getMore(_batchSize: number): Promise<CursorResponse> {
     if (!this.session) {
       throw new MongoRuntimeError(
         'Unexpected null session. A cursor creating command should have set this'

package/src/error.ts

@@ -97,7 +97,7 @@ export const MongoErrorLabel = Object.freeze({
   ResumableChangeStreamError: 'ResumableChangeStreamError',
   HandshakeError: 'HandshakeError',
   ResetPool: 'ResetPool',
-  PoolRequestedRetry: 'PoolRequestedRetry',
+  PoolRequstedRetry: 'PoolRequstedRetry',
   InterruptInUseConnections: 'InterruptInUseConnections',
   NoWritesPerformed: 'NoWritesPerformed'
 } as const);
@@ -1444,7 +1444,7 @@ export function needsRetryableWriteLabel(
 export function isRetryableWriteError(error: MongoError): boolean {
   return (
     error.hasErrorLabel(MongoErrorLabel.RetryableWriteError) ||
-    error.hasErrorLabel(MongoErrorLabel.PoolRequestedRetry)
+    error.hasErrorLabel(MongoErrorLabel.PoolRequstedRetry)
   );
 }
 

package/src/gridfs/download.ts

@@ -53,6 +53,10 @@ export interface GridFSFile {
   filename: string;
   metadata?: Document;
   uploadDate: Date;
+  /** @deprecated Will be removed in the next major version. */
+  contentType?: string;
+  /** @deprecated Will be removed in the next major version. */
+  aliases?: string[];
 }
 
 /** @internal */

package/src/gridfs/upload.ts

@@ -32,6 +32,16 @@ export interface GridFSBucketWriteStreamOptions extends WriteConcernOptions {
   id?: ObjectId;
   /** Object to store in the file document's `metadata` field */
   metadata?: Document;
+  /**
+   * String to store in the file document's `contentType` field.
+   * @deprecated Will be removed in the next major version. Add a contentType field to the metadata document instead.
+   */
+  contentType?: string;
+  /**
+   * Array of strings to store in the file document's `aliases` field.
+   * @deprecated Will be removed in the next major version. Add an aliases field to the metadata document instead.
+   */
+  aliases?: string[];
   /**
    * @experimental
    * Specifies the time an operation will run until it throws a timeout error
@@ -295,6 +305,8 @@ function checkDone(stream: GridFSBucketWriteStream, callback: Callback): void {
       stream.length,
       stream.chunkSizeBytes,
       stream.filename,
+      stream.options.contentType,
+      stream.options.aliases,
       stream.options.metadata
     );
 
@@ -390,6 +402,8 @@ function createFilesDoc(
   length: number,
   chunkSize: number,
   filename: string,
+  contentType?: string,
+  aliases?: string[],
   metadata?: Document
 ): GridFSFile {
   const ret: GridFSFile = {
@@ -400,6 +414,14 @@ function createFilesDoc(
     filename
   };
 
+  if (contentType) {
+    ret.contentType = contentType;
+  }
+
+  if (aliases) {
+    ret.aliases = aliases;
+  }
+
   if (metadata) {
     ret.metadata = metadata;
   }

package/src/index.ts

@@ -87,6 +87,7 @@ export {
   MongoWriteConcernError,
   WriteConcernErrorResult
 } from './error';
+export { configureExplicitResourceManagement } from './resource_management';
 export {
   AbstractCursor,
   // Actual driver classes exported
@@ -223,6 +224,7 @@ export type {
   ChangeStreamSplitEvent,
   ChangeStreamUpdateDocument,
   OperationTime,
+  ResumeOptions,
   ResumeToken,
   UpdateDescription
 } from './change_stream';
@@ -305,6 +307,7 @@ export type {
   ProxyOptions
 } from './cmap/connection';
 export type {
+  CloseOptions,
   ConnectionPool,
   ConnectionPoolEvents,
   ConnectionPoolOptions,
@@ -312,7 +315,7 @@ export type {
   WaitQueueMember,
   WithConnectionCallback
 } from './cmap/connection_pool';
-export type { ClientMetadata } from './cmap/handshake/client_metadata';
+export type { ClientMetadata, ClientMetadataOptions } from './cmap/handshake/client_metadata';
 export type { ConnectionPoolMetrics } from './cmap/metrics';
 export type { StreamDescription, StreamDescriptionOptions } from './cmap/stream_description';
 export type { CompressorName } from './cmap/wire_protocol/compression';
@@ -365,7 +368,8 @@ export type {
 export type {
   AbstractCursorEvents,
   AbstractCursorOptions,
-  CursorFlag
+  CursorFlag,
+  CursorStreamOptions
 } from './cursor/abstract_cursor';
 export type {
   CursorTimeoutContext,
@@ -562,6 +566,7 @@ export type {
   ReadPreferenceLikeOptions,
   ReadPreferenceOptions
 } from './read_preference';
+export type { AsyncDisposable } from './resource_management';
 export type { ClusterTime } from './sdam/common';
 export type {
   Monitor,
@@ -593,6 +598,7 @@ export type { SrvPoller, SrvPollerEvents, SrvPollerOptions } from './sdam/srv_po
 export type {
   ConnectOptions,
   SelectServerOptions,
+  ServerCapabilities,
   ServerSelectionCallback,
   ServerSelectionRequest,
   Topology,

package/src/mongo_client.ts

@@ -2,7 +2,7 @@ import { promises as fs } from 'fs';
 import type { TcpNetConnectOpts } from 'net';
 import type { ConnectionOptions as TLSConnectionOptions, TLSSocketOptions } from 'tls';
 
-import { TopologyType } from '.';
+import { type ServerCommandOptions, type TimeoutContext } from '.';
 import { type BSONSerializeOptions, type Document, resolveBSONOptions } from './bson';
 import { ChangeStream, type ChangeStreamDocument, type ChangeStreamOptions } from './change_stream';
 import type { AutoEncrypter, AutoEncryptionOptions } from './client-side-encryption/auto_encrypter';
@@ -16,11 +16,13 @@ import { AuthMechanism } from './cmap/auth/providers';
 import type { LEGAL_TCP_SOCKET_OPTIONS, LEGAL_TLS_SOCKET_OPTIONS } from './cmap/connect';
 import type { Connection } from './cmap/connection';
 import {
+  addContainerMetadata,
   type ClientMetadata,
   isDriverInfoEqual,
   makeClientMetadata
 } from './cmap/handshake/client_metadata';
 import type { CompressorName } from './cmap/wire_protocol/compression';
+import { MongoDBResponse } from './cmap/wire_protocol/responses';
 import { parseOptions, resolveSRVRecord } from './connection_string';
 import { MONGO_CLIENT_EVENTS } from './constants';
 import { type AbstractCursor } from './cursor/abstract_cursor';
@@ -42,10 +44,11 @@ import {
   type ClientBulkWriteResult
 } from './operations/client_bulk_write/common';
 import { ClientBulkWriteExecutor } from './operations/client_bulk_write/executor';
-import { EndSessionsOperation } from './operations/end_sessions';
 import { executeOperation } from './operations/execute_operation';
+import { AbstractOperation } from './operations/operation';
 import type { ReadConcern, ReadConcernLevel, ReadConcernLike } from './read_concern';
 import { ReadPreference, type ReadPreferenceMode } from './read_preference';
+import { type AsyncDisposable, configureResourceManagement } from './resource_management';
 import type { ServerMonitoringMode } from './sdam/monitor';
 import type { TagSet } from './sdam/server_description';
 import { readPreferenceServerSelector } from './sdam/server_selection';
@@ -60,7 +63,7 @@ import {
   type HostAddress,
   hostMatchesWildcards,
   isHostMatch,
-  type MongoDBNamespace,
+  MongoDBNamespace,
   noop,
   ns,
   resolveOptions,
@@ -405,12 +408,31 @@ export class MongoClient extends TypedEventEmitter<MongoClientEvents> implements
    * The consolidate, parsed, transformed and merged options.
    */
   public readonly options: Readonly<
-    Omit<MongoOptions, 'monitorCommands' | 'ca' | 'crl' | 'key' | 'cert' | 'driverInfo'>
+    Omit<
+      MongoOptions,
+      | 'monitorCommands'
+      | 'ca'
+      | 'crl'
+      | 'key'
+      | 'cert'
+      | 'driverInfo'
+      | 'additionalDriverInfo'
+      | 'metadata'
+      | 'extendedMetadata'
+    >
   > &
-    Pick<MongoOptions, 'monitorCommands' | 'ca' | 'crl' | 'key' | 'cert' | 'driverInfo'> & {
-      /** @internal */
-      metadata: Promise<ClientMetadata>;
-    };
+    Pick<
+      MongoOptions,
+      | 'monitorCommands'
+      | 'ca'
+      | 'crl'
+      | 'key'
+      | 'cert'
+      | 'driverInfo'
+      | 'additionalDriverInfo'
+      | 'metadata'
+      | 'extendedMetadata'
+    >;
 
   private driverInfoList: DriverInfo[] = [];
 
@@ -463,10 +485,13 @@ export class MongoClient extends TypedEventEmitter<MongoClientEvents> implements
   }
 
   /**
+   * @beta
    * @experimental
    * An alias for {@link MongoClient.close|MongoClient.close()}.
    */
-  async [Symbol.asyncDispose]() {
+  declare [Symbol.asyncDispose]: () => Promise<void>;
+  /** @internal */
+  async asyncDispose() {
     await this.close();
   }
 
@@ -481,9 +506,10 @@ export class MongoClient extends TypedEventEmitter<MongoClientEvents> implements
     if (isDuplicateDriverInfo) return;
 
     this.driverInfoList.push(driverInfo);
-    this.options.metadata = makeClientMetadata(this.driverInfoList, this.options)
+    this.options.metadata = makeClientMetadata(this.driverInfoList, this.options);
+    this.options.extendedMetadata = addContainerMetadata(this.options.metadata)
       .then(undefined, squashError)
-      .then(result => result ?? ({} as ClientMetadata)); // ensure Promise<Document>
+      .then(result => result ?? {}); // ensure Promise<Document>
   }
 
   /** @internal */
@@ -568,13 +594,20 @@ export class MongoClient extends TypedEventEmitter<MongoClientEvents> implements
   }
 
   /**
-   * An optional method to verify a handful of assumptions that are generally useful at application boot-time before using a MongoClient.
-   * For detailed information about the connect process see the MongoClient.connect static method documentation.
+   * Connect to MongoDB using a url
    *
-   * @param url - The MongoDB connection string (supports `mongodb://` and `mongodb+srv://` schemes)
-   * @param options - Optional configuration options for the client
+   * @remarks
+   * Calling `connect` is optional since the first operation you perform will call `connect` if it's needed.
+   * `timeoutMS` will bound the time any operation can take before throwing a timeout error.
+   * However, when the operation being run is automatically connecting your `MongoClient` the `timeoutMS` will not apply to the time taken to connect the MongoClient.
+   * This means the time to setup the `MongoClient` does not count against `timeoutMS`.
+   * If you are using `timeoutMS` we recommend connecting your client explicitly in advance of any operation to avoid this inconsistent execution time.
    *
-   * @see https://www.mongodb.com/docs/manual/reference/connection-string/
+   * @remarks
+   * The driver will look up corresponding SRV and TXT records if the connection string starts with `mongodb+srv://`.
+   * If those look ups throw a DNS Timeout error, the driver will retry the look up once.
+   *
+   * @see docs.mongodb.org/manual/reference/connection-string/
    */
   async connect(): Promise<this> {
     if (this.connectionLock) {
@@ -762,12 +795,40 @@ export class MongoClient extends TypedEventEmitter<MongoClientEvents> implements
       return;
     }
 
-    const supportsSessions =
-      this.topology.description.type === TopologyType.LoadBalanced ||
-      this.topology.description.logicalSessionTimeoutMinutes != null;
-
-    if (supportsSessions) {
-      await endSessions(this, this.topology);
+    // If we would attempt to select a server and get nothing back we short circuit
+    // to avoid the server selection timeout.
+    const selector = readPreferenceServerSelector(ReadPreference.primaryPreferred);
+    const topologyDescription = this.topology.description;
+    const serverDescriptions = Array.from(topologyDescription.servers.values());
+    const servers = selector(topologyDescription, serverDescriptions);
+    if (servers.length !== 0) {
+      const endSessions = Array.from(this.s.sessionPool.sessions, ({ id }) => id);
+      if (endSessions.length !== 0) {
+        try {
+          class EndSessionsOperation extends AbstractOperation<void> {
+            override ns = MongoDBNamespace.fromString('admin.$cmd');
+            override SERVER_COMMAND_RESPONSE_TYPE = MongoDBResponse;
+            override buildCommand(_connection: Connection, _session?: ClientSession): Document {
+              return {
+                endSessions
+              };
+            }
+            override buildOptions(timeoutContext: TimeoutContext): ServerCommandOptions {
+              return {
+                timeoutContext,
+                readPreference: ReadPreference.primaryPreferred,
+                noResponse: true
+              };
+            }
+            override get commandName(): string {
+              return 'endSessions';
+            }
+          }
+          await executeOperation(this, new EndSessionsOperation());
+        } catch (error) {
+          squashError(error);
+        }
+      }
     }
 
     // clear out references to old topology
@@ -780,27 +841,6 @@ export class MongoClient extends TypedEventEmitter<MongoClientEvents> implements
     if (encrypter) {
       await encrypter.close(this);
     }
-
-    async function endSessions(
-      client: MongoClient,
-      { description: topologyDescription }: Topology
-    ) {
-      // If we would attempt to select a server and get nothing back we short circuit
-      // to avoid the server selection timeout.
-      const selector = readPreferenceServerSelector(ReadPreference.primaryPreferred);
-      const serverDescriptions = Array.from(topologyDescription.servers.values());
-      const servers = selector(topologyDescription, serverDescriptions);
-      if (servers.length !== 0) {
-        const endSessions = Array.from(client.s.sessionPool.sessions, ({ id }) => id);
-        if (endSessions.length !== 0) {
-          try {
-            await executeOperation(client, new EndSessionsOperation(endSessions));
-          } catch (error) {
-            squashError(error);
-          }
-        }
-      }
-    }
   }
 
   /**
@@ -828,35 +868,21 @@ export class MongoClient extends TypedEventEmitter<MongoClientEvents> implements
   }
 
   /**
-   * Creates a new MongoClient instance and immediately connects it to MongoDB.
-   * This convenience method combines `new MongoClient(url, options)` and `client.connect()` in a single step.
-   *
-   * Connect can be helpful to detect configuration issues early by validating:
-   * - **DNS Resolution**: Verifies that SRV records and hostnames in the connection string resolve DNS entries
-   * - **Network Connectivity**: Confirms that host addresses are reachable and ports are open
-   * - **TLS Configuration**: Validates SSL/TLS certificates, CA files, and encryption settings are correct
-   * - **Authentication**: Verifies that provided credentials are valid
-   * - **Server Compatibility**: Ensures the MongoDB server version is supported by this driver version
-   * - **Load Balancer Setup**: For load-balanced deployments, confirms the service is properly configured
-   *
-   * @returns A promise that resolves to the same MongoClient instance once connected
+   * Connect to MongoDB using a url
    *
    * @remarks
-   * **Connection is Optional:** Calling `connect` is optional since any operation method (`find`, `insertOne`, etc.)
-   * will automatically perform these same validation steps if the client is not already connected.
-   * However, explicitly calling `connect` can make sense for:
-   * - **Fail-fast Error Detection**: Non-transient connection issues (hostname unresolved, port refused connection) are discovered immediately rather than during your first operation
-   * - **Predictable Performance**: Eliminates first connection overhead from your first database operation
+   * Calling `connect` is optional since the first operation you perform will call `connect` if it's needed.
+   * `timeoutMS` will bound the time any operation can take before throwing a timeout error.
+   * However, when the operation being run is automatically connecting your `MongoClient` the `timeoutMS` will not apply to the time taken to connect the MongoClient.
+   * This means the time to setup the `MongoClient` does not count against `timeoutMS`.
+   * If you are using `timeoutMS` we recommend connecting your client explicitly in advance of any operation to avoid this inconsistent execution time.
    *
    * @remarks
-   * **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).
+   * The programmatically provided options take precedence over the URI options.
    *
    * @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.
+   * The driver will look up corresponding SRV and TXT records if the connection string starts with `mongodb+srv://`.
+   * If those look ups throw a DNS Timeout error, the driver will retry the look up once.
    *
    * @see https://www.mongodb.com/docs/manual/reference/connection-string/
    */
@@ -1011,6 +1037,8 @@ export class MongoClient extends TypedEventEmitter<MongoClientEvents> implements
   }
 }
 
+configureResourceManagement(MongoClient.prototype);
+
 /**
  * Parsed Mongo Client Options.
  *
@@ -1077,8 +1105,12 @@ export interface MongoOptions
   compressors: CompressorName[];
   writeConcern: WriteConcern;
   dbName: string;
-  /** @internal */
-  metadata: Promise<ClientMetadata>;
+  /** @deprecated - Will be made internal in a future major release. */
+  metadata: ClientMetadata;
+  /** @deprecated - Will be made internal in a future major release. */
+  extendedMetadata: Promise<Document>;
+  /** @deprecated - Will be made internal in a future major release. */
+  additionalDriverInfo: DriverInfo[];
   /** @internal */
   autoEncrypter?: AutoEncrypter;
   /** @internal */