mongodb 6.17.0 → 6.18.0-dev.20250723.sha.d92acfc1

package/src/cmap/connection_pool.ts

@@ -610,13 +610,17 @@ export class ConnectionPool extends TypedEventEmitter<ConnectionPoolEvents> {
   }
 
   private createConnection(callback: Callback<Connection>) {
+    // Note that metadata and extendedMetadata may have changed on the client but have
+    // been frozen here, so we pull the extendedMetadata promise always from the client
+    // no mattter what options were set at the construction of the pool.
     const connectOptions: ConnectionOptions = {
       ...this.options,
       id: this.connectionCounter.next().value,
       generation: this.generation,
       cancellationToken: this.cancellationToken,
       mongoLogger: this.mongoLogger,
-      authProviders: this.server.topology.client.s.authProviders
+      authProviders: this.server.topology.client.s.authProviders,
+      extendedMetadata: this.server.topology.client.options.extendedMetadata
     };
 
     this.pending++;
@@ -691,7 +695,7 @@ export class ConnectionPool extends TypedEventEmitter<ConnectionPoolEvents> {
 
   private ensureMinPoolSize() {
     const minPoolSize = this.options.minPoolSize;
-    if (this.poolState !== PoolState.ready || minPoolSize === 0) {
+    if (this.poolState !== PoolState.ready) {
       return;
     }
 

package/src/cmap/handshake/client_metadata.ts

@@ -2,7 +2,7 @@ import * as os from 'os';
 import * as process from 'process';
 
 import { BSON, type Document, Int32 } from '../../bson';
-import { MongoInvalidArgumentError } from '../../error';
+import { MongoInvalidArgumentError, MongoRuntimeError } from '../../error';
 import type { MongoOptions } from '../../mongo_client';
 import { fileIsAccessible } from '../../utils';
 
@@ -11,6 +11,7 @@ const NODE_DRIVER_VERSION = require('../../../package.json').version;
 
 /**
  * @public
+ * @deprecated This interface will be made internal in the next major release.
  * @see https://github.com/mongodb/specifications/blob/master/source/mongodb-handshake/handshake.md#hello-command
  */
 export interface ClientMetadata {
@@ -38,7 +39,10 @@ export interface ClientMetadata {
   };
 }
 
-/** @public */
+/**
+ * @public
+ * @deprecated This interface will be made internal in the next major release.
+ */
 export interface ClientMetadataOptions {
   driverInfo?: {
     name?: string;
@@ -53,7 +57,11 @@ export class LimitedSizeDocument {
   private document = new Map();
   /** BSON overhead: Int32 + Null byte */
   private documentSize = 5;
-  constructor(private maxSize: number) {}
+  private maxSize: number;
+
+  constructor(maxSize: number) {
+    this.maxSize = maxSize;
+  }
 
   /** Only adds key/value if the bsonByteLength is less than MAX_SIZE */
   public ifItFitsItSits(key: string, value: Record<string, any> | string): boolean {
@@ -82,7 +90,10 @@ export class LimitedSizeDocument {
   }
 }
 
-type MakeClientMetadataOptions = Pick<MongoOptions, 'appName' | 'driverInfo'>;
+type MakeClientMetadataOptions = Pick<
+  MongoOptions,
+  'appName' | 'driverInfo' | 'additionalDriverInfo'
+>;
 /**
  * From the specs:
  * Implementors SHOULD cumulatively update fields in the following order until the document is under the size limit:
@@ -111,6 +122,22 @@ export function makeClientMetadata(options: MakeClientMetadataOptions): ClientMe
     version: version.length > 0 ? `${NODE_DRIVER_VERSION}|${version}` : NODE_DRIVER_VERSION
   };
 
+  if (options.additionalDriverInfo == null) {
+    throw new MongoRuntimeError(
+      'Client options `additionalDriverInfo` must always default to an empty array'
+    );
+  }
+
+  // This is where we handle additional driver info added after client construction.
+  for (const { name: n = '', version: v = '' } of options.additionalDriverInfo) {
+    if (n.length > 0) {
+      driverInfo.name = `${driverInfo.name}|${n}`;
+    }
+    if (v.length > 0) {
+      driverInfo.version = `${driverInfo.version}|${v}`;
+    }
+  }
+
   if (!metadataDocument.ifItFitsItSits('driver', driverInfo)) {
     throw new MongoInvalidArgumentError(
       'Unable to include driverInfo name and version, metadata cannot exceed 512 bytes'
@@ -122,6 +149,12 @@ export function makeClientMetadata(options: MakeClientMetadataOptions): ClientMe
     runtimeInfo = `${runtimeInfo}|${platform}`;
   }
 
+  for (const { platform: p = '' } of options.additionalDriverInfo) {
+    if (p.length > 0) {
+      runtimeInfo = `${runtimeInfo}|${p}`;
+    }
+  }
+
   if (!metadataDocument.ifItFitsItSits('platform', runtimeInfo)) {
     throw new MongoInvalidArgumentError(
       'Unable to include driverInfo platform, metadata cannot exceed 512 bytes'

package/src/cmap/wire_protocol/compression.ts

@@ -7,6 +7,7 @@ import { MongoDecompressionError, MongoInvalidArgumentError } from '../../error'
 import {
   type MessageHeader,
   OpCompressedRequest,
+  type OpCompressesRequestOptions,
   OpMsgResponse,
   OpReply,
   type WriteProtocolMessageType
@@ -60,7 +61,7 @@ function loadSnappy() {
 
 // Facilitate compressing a message using an agreed compressor
 export async function compress(
-  options: { zlibCompressionLevel: number; agreedCompressor: CompressorName },
+  options: OpCompressesRequestOptions,
   dataToBeCompressed: Buffer
 ): Promise<Buffer> {
   const zlibOptions = {} as zlib.ZlibOptions;

package/src/cmap/wire_protocol/on_data.ts

@@ -87,6 +87,11 @@ export function onData(
 
     [Symbol.asyncIterator]() {
       return this;
+    },
+
+    // Note this should currently not be used, but is required by the AsyncGenerator interface.
+    async [Symbol.asyncDispose]() {
+      await closeHandler();
     }
   };
 

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

@@ -14,14 +14,13 @@ import {
   toUTF8
 } from '../../../bson';
 
-// eslint-disable-next-line no-restricted-syntax
-const enum BSONElementOffset {
-  type = 0,
-  nameOffset = 1,
-  nameLength = 2,
-  offset = 3,
-  length = 4
-}
+const BSONElementOffset = {
+  type: 0,
+  nameOffset: 1,
+  nameLength: 2,
+  offset: 3,
+  length: 4
+} as const;
 
 /** @internal */
 export type JSTypeOf = {
@@ -67,17 +66,23 @@ export class OnDemandDocument {
 
   /** All bson elements in this document */
   private readonly elements: ReadonlyArray<BSONElement>;
+  /** BSON bytes, this document begins at offset */
+  protected readonly bson: Uint8Array;
+  /** The start of the document */
+  private readonly offset: number;
+  /** If this is an embedded document, indicates if this was a BSON array */
+  public readonly isArray: boolean;
 
   constructor(
-    /** BSON bytes, this document begins at offset */
-    protected readonly bson: Uint8Array,
-    /** The start of the document */
-    private readonly offset = 0,
-    /** If this is an embedded document, indicates if this was a BSON array */
-    public readonly isArray = false,
+    bson: Uint8Array,
+    offset = 0,
+    isArray = false,
     /** If elements was already calculated */
     elements?: BSONElement[]
   ) {
+    this.bson = bson;
+    this.offset = offset;
+    this.isArray = isArray;
     this.elements = elements ?? parseToElementsToArray(this.bson, offset);
   }
 

package/src/cmap/wire_protocol/responses.ts

@@ -20,14 +20,14 @@ import {
   type OnDemandDocumentDeserializeOptions
 } from './on_demand/document';
 
-// eslint-disable-next-line no-restricted-syntax
-const enum BSONElementOffset {
-  type = 0,
-  nameOffset = 1,
-  nameLength = 2,
-  offset = 3,
-  length = 4
-}
+const BSONElementOffset = {
+  type: 0,
+  nameOffset: 1,
+  nameLength: 2,
+  offset: 3,
+  length: 4
+} as const;
+
 /**
  * Accepts a BSON payload and checks for na "ok: 0" element.
  * This utility is intended to prevent calling response class constructors

package/src/connection_string.ts

@@ -172,11 +172,6 @@ function checkTLSOptions(allOptions: CaseInsensitiveMap): void {
   };
   check('tlsInsecure', 'tlsAllowInvalidCertificates');
   check('tlsInsecure', 'tlsAllowInvalidHostnames');
-  check('tlsInsecure', 'tlsDisableCertificateRevocationCheck');
-  check('tlsInsecure', 'tlsDisableOCSPEndpointCheck');
-  check('tlsAllowInvalidCertificates', 'tlsDisableCertificateRevocationCheck');
-  check('tlsAllowInvalidCertificates', 'tlsDisableOCSPEndpointCheck');
-  check('tlsDisableCertificateRevocationCheck', 'tlsDisableOCSPEndpointCheck');
 }
 function getBoolean(name: string, value: unknown): boolean {
   if (typeof value === 'boolean') return value;
@@ -540,6 +535,9 @@ export function parseOptions(
     }
   );
 
+  // Set the default for the additional driver info.
+  mongoOptions.additionalDriverInfo = [];
+
   mongoOptions.metadata = makeClientMetadata(mongoOptions);
 
   mongoOptions.extendedMetadata = addContainerMetadata(mongoOptions.metadata).then(
@@ -605,6 +603,8 @@ function setOption(
       if (values[0] == null) {
         break;
       }
+      // The value should always be a string here, but since the array is typed as unknown
+      // there still needs to be an explicit cast.
       // eslint-disable-next-line @typescript-eslint/no-base-to-string
       mongoOptions[name] = String(values[0]);
       break;

package/src/cursor/abstract_cursor.ts

@@ -20,7 +20,7 @@ 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 { ClientSession, maybeClearPinnedConnection } from '../sessions';
+import { type ClientSession, maybeClearPinnedConnection } from '../sessions';
 import { type CSOTTimeoutContext, type Timeout, TimeoutContext } from '../timeout';
 import {
   addAbortListener,
@@ -227,7 +227,7 @@ export abstract class AbstractCursor<
   /** @internal */
   private cursorId: Long | null;
   /** @internal */
-  private cursorSession: ClientSession;
+  private cursorSession: ClientSession | null;
   /** @internal */
   private selectedServer?: Server;
   /** @internal */
@@ -352,11 +352,7 @@ export abstract class AbstractCursor<
       this.cursorOptions.maxAwaitTimeMS = options.maxAwaitTimeMS;
     }
 
-    if (options.session instanceof ClientSession) {
-      this.cursorSession = options.session;
-    } else {
-      this.cursorSession = this.cursorClient.startSession({ owner: this, explicit: false });
-    }
+    this.cursorSession = options.session ?? null;
 
     this.deserializationOptions = {
       ...this.cursorOptions,
@@ -413,7 +409,7 @@ export abstract class AbstractCursor<
   }
 
   /** @internal */
-  get session(): ClientSession {
+  get session(): ClientSession | null {
     return this.cursorSession;
   }
 
@@ -877,11 +873,12 @@ export abstract class AbstractCursor<
     this.trackCursor();
 
     // We only want to end this session if we created it, and it hasn't ended yet
-    if (this.cursorSession.explicit === false) {
+    if (this.cursorSession?.explicit === false) {
       if (!this.cursorSession.hasEnded) {
         this.cursorSession.endSession().then(undefined, squashError);
       }
-      this.cursorSession = this.cursorClient.startSession({ owner: this, explicit: false });
+
+      this.cursorSession = null;
     }
   }
 
@@ -907,6 +904,13 @@ export abstract class AbstractCursor<
         'Unexpected null selectedServer. A cursor creating command should have set this'
       );
     }
+
+    if (this.cursorSession == null) {
+      throw new MongoRuntimeError(
+        'Unexpected null session. A cursor creating command should have set this'
+      );
+    }
+
     const getMoreOptions = {
       ...this.cursorOptions,
       session: this.cursorSession,
@@ -941,6 +945,7 @@ export abstract class AbstractCursor<
       );
     }
     try {
+      this.cursorSession ??= this.cursorClient.startSession({ owner: this, explicit: false });
       const state = await this._initialize(this.cursorSession);
       // Set omitMaxTimeMS to the value needed for subsequent getMore calls
       this.cursorOptions.omitMaxTimeMS = this.cursorOptions.timeoutMS != null;
@@ -1032,41 +1037,57 @@ export abstract class AbstractCursor<
         return this.timeoutContext?.refreshed();
       }
     };
-    try {
-      if (
-        !this.isKilled &&
-        this.cursorId &&
-        !this.cursorId.isZero() &&
-        this.cursorNamespace &&
-        this.selectedServer &&
-        !this.cursorSession.hasEnded
-      ) {
-        this.isKilled = true;
-        const cursorId = this.cursorId;
-        this.cursorId = Long.ZERO;
-
-        await executeOperation(
-          this.cursorClient,
-          new KillCursorsOperation(cursorId, this.cursorNamespace, this.selectedServer, {
-            session: this.cursorSession
-          }),
-          timeoutContextForKillCursors()
-        );
+
+    const withEmitClose = async (fn: () => Promise<void>) => {
+      try {
+        await fn();
+      } finally {
+        this.emitClose();
       }
-    } catch (error) {
-      squashError(error);
-    } finally {
+    };
+
+    const close = async () => {
+      // if no session has been defined on the cursor, the cursor was never initialized
+      // or the cursor was re-wound and never re-iterated.  In either case, we
+      //   1. do not need to end the session (there is no session after all)
+      //   2. do not need to kill the cursor server-side
+      const session = this.cursorSession;
+      if (!session) return;
+
       try {
-        if (this.cursorSession?.owner === this) {
-          await this.cursorSession.endSession({ error });
-        }
-        if (!this.cursorSession?.inTransaction()) {
-          maybeClearPinnedConnection(this.cursorSession, { error });
+        if (
+          !this.isKilled &&
+          this.cursorId &&
+          !this.cursorId.isZero() &&
+          this.cursorNamespace &&
+          this.selectedServer &&
+          !session.hasEnded
+        ) {
+          this.isKilled = true;
+          const cursorId = this.cursorId;
+          this.cursorId = Long.ZERO;
+
+          await executeOperation(
+            this.cursorClient,
+            new KillCursorsOperation(cursorId, this.cursorNamespace, this.selectedServer, {
+              session
+            }),
+            timeoutContextForKillCursors()
+          );
         }
+      } catch (error) {
+        squashError(error);
       } finally {
-        this.emitClose();
+        if (session.owner === this) {
+          await session.endSession({ error });
+        }
+        if (!session.inTransaction()) {
+          maybeClearPinnedConnection(session, { error });
+        }
       }
-    }
+    };
+
+    await withEmitClose(close);
   }
 
   /** @internal */
@@ -1213,11 +1234,13 @@ configureResourceManagement(AbstractCursor.prototype);
  * All timeout behavior is exactly the same as the wrapped timeout context's.
  */
 export class CursorTimeoutContext extends TimeoutContext {
-  constructor(
-    public timeoutContext: TimeoutContext,
-    public owner: symbol | AbstractCursor
-  ) {
+  timeoutContext: TimeoutContext;
+  owner: symbol | AbstractCursor;
+
+  constructor(timeoutContext: TimeoutContext, owner: symbol | AbstractCursor) {
     super();
+    this.timeoutContext = timeoutContext;
+    this.owner = owner;
   }
   override get serverSelectionTimeout(): Timeout | null {
     return this.timeoutContext.serverSelectionTimeout;

package/src/cursor/run_command_cursor.ts

@@ -1,7 +1,7 @@
 import type { BSONSerializeOptions, Document } from '../bson';
 import { CursorResponse } from '../cmap/wire_protocol/responses';
 import type { Db } from '../db';
-import { MongoAPIError } from '../error';
+import { MongoAPIError, MongoRuntimeError } from '../error';
 import { executeOperation } from '../operations/execute_operation';
 import { GetMoreOperation } from '../operations/get_more';
 import { RunCommandOperation } from '../operations/run_command';
@@ -161,6 +161,12 @@ export class RunCommandCursor extends AbstractCursor {
 
   /** @internal */
   override async getMore(_batchSize: number): Promise<CursorResponse> {
+    if (!this.session) {
+      throw new MongoRuntimeError(
+        'Unexpected null session. A cursor creating command should have set this'
+      );
+    }
+
     // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
     const getMoreOperation = new GetMoreOperation(this.namespace, this.id!, this.server!, {
       ...this.cursorOptions,

package/src/index.ts

@@ -208,6 +208,7 @@ export type {
   ChangeStreamDocumentCommon,
   ChangeStreamDocumentKey,
   ChangeStreamDocumentOperationDescription,
+  ChangeStreamDocumentWallTime,
   ChangeStreamDropDatabaseDocument,
   ChangeStreamDropDocument,
   ChangeStreamDropIndexDocument,
@@ -287,6 +288,7 @@ export type { TokenCache } from './cmap/auth/mongodb_oidc/token_cache';
 export type {
   MessageHeader,
   OpCompressedRequest,
+  OpCompressesRequestOptions,
   OpMsgOptions,
   OpMsgRequest,
   OpMsgResponse,

package/src/mongo_client.ts

@@ -14,7 +14,11 @@ import { type TokenCache } from './cmap/auth/mongodb_oidc/token_cache';
 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 type { ClientMetadata } from './cmap/handshake/client_metadata';
+import {
+  addContainerMetadata,
+  type ClientMetadata,
+  makeClientMetadata
+} from './cmap/handshake/client_metadata';
 import type { CompressorName } from './cmap/wire_protocol/compression';
 import { parseOptions, resolveSRVRecord } from './connection_string';
 import { MONGO_CLIENT_EVENTS } from './constants';
@@ -184,7 +188,11 @@ export interface MongoClientOptions extends BSONSerializeOptions, SupportedNodeC
   minPoolSize?: number;
   /** The maximum number of connections that may be in the process of being established concurrently by the connection pool. */
   maxConnecting?: number;
-  /** The maximum number of milliseconds that a connection can remain idle in the pool before being removed and closed. */
+  /**
+   * The maximum amount of time a connection should remain idle in the connection pool before being marked idle, in milliseconds.
+   * If specified, this must be a number greater than or equal to 0, where 0 means there is no limit. Defaults to 0. After this
+   * time passes, the idle collection can be automatically cleaned up in the background.
+   */
   maxIdleTimeMS?: number;
   /** The maximum time in milliseconds that a thread can wait for a connection to become available. */
   waitQueueTimeoutMS?: number;
@@ -394,9 +402,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'>
+    Omit<
+      MongoOptions,
+      | 'monitorCommands'
+      | 'ca'
+      | 'crl'
+      | 'key'
+      | 'cert'
+      | 'driverInfo'
+      | 'additionalDriverInfo'
+      | 'metadata'
+      | 'extendedMetadata'
+    >
   > &
-    Pick<MongoOptions, 'monitorCommands' | 'ca' | 'crl' | 'key' | 'cert'>;
+    Pick<
+      MongoOptions,
+      | 'monitorCommands'
+      | 'ca'
+      | 'crl'
+      | 'key'
+      | 'cert'
+      | 'driverInfo'
+      | 'additionalDriverInfo'
+      | 'metadata'
+      | 'extendedMetadata'
+    >;
 
   constructor(url: string, options?: MongoClientOptions) {
     super();
@@ -455,6 +485,18 @@ export class MongoClient extends TypedEventEmitter<MongoClientEvents> implements
     await this.close();
   }
 
+  /**
+   * Append metadata to the client metadata after instantiation.
+   * @param driverInfo - Information about the application or library.
+   */
+  appendMetadata(driverInfo: DriverInfo) {
+    this.options.additionalDriverInfo.push(driverInfo);
+    this.options.metadata = makeClientMetadata(this.options);
+    this.options.extendedMetadata = addContainerMetadata(this.options.metadata)
+      .then(undefined, squashError)
+      .then(result => result ?? {}); // ensure Promise<Document>
+  }
+
   /** @internal */
   private checkForNonGenuineHosts() {
     const documentDBHostnames = this.options.hosts.filter((hostAddress: HostAddress) =>
@@ -1035,9 +1077,10 @@ export interface MongoOptions
   compressors: CompressorName[];
   writeConcern: WriteConcern;
   dbName: string;
+  /** @deprecated - Will be made internal in a future major release. */
   metadata: ClientMetadata;
-  /** @internal */
   extendedMetadata: Promise<Document>;
+  additionalDriverInfo: DriverInfo[];
   /** @internal */
   autoEncrypter?: AutoEncrypter;
   /** @internal */

package/src/mongo_types.ts

@@ -472,7 +472,10 @@ export class TypedEventEmitter<Events extends EventsDescription> extends EventEm
   }
 }
 
-/** @public */
+/**
+ * @public
+ * @deprecated Will be removed in favor of `AbortSignal` in the next major release.
+ */
 export class CancellationToken extends TypedEventEmitter<{ cancel(): void }> {
   constructor(...args: any[]) {
     super(...args);

package/src/operations/command.ts

@@ -59,6 +59,10 @@ export interface CommandOperationOptions
   // Admin command overrides.
   dbName?: string;
   authdb?: string;
+  /**
+   * @deprecated
+   * This option is deprecated and will be removed in an upcoming major version.
+   */
   noResponse?: boolean;
 }
 

package/src/operations/distinct.ts

@@ -96,6 +96,7 @@ export class DistinctOperation extends CommandOperation<any[]> {
 
     const result = await super.executeCommand(server, session, cmd, timeoutContext);
 
+    // @ts-expect-error: Explain always returns a document
     return this.explain ? result : result.values;
   }
 }

package/src/operations/rename.ts

@@ -17,12 +17,15 @@ export interface RenameOptions extends CommandOperationOptions {
 
 /** @internal */
 export class RenameOperation extends CommandOperation<Document> {
-  constructor(
-    public collection: Collection,
-    public newName: string,
-    public override options: RenameOptions
-  ) {
+  collection: Collection;
+  newName: string;
+  override options: RenameOptions;
+
+  constructor(collection: Collection, newName: string, options: RenameOptions) {
     super(collection, options);
+    this.collection = collection;
+    this.newName = newName;
+    this.options = options;
     this.ns = new MongoDBNamespace('admin', '$cmd');
   }
 

package/src/operations/run_command.ts

@@ -26,12 +26,17 @@ export type RunCommandOptions = {
 
 /** @internal */
 export class RunCommandOperation<T = Document> extends AbstractOperation<T> {
+  command: Document;
+  override options: RunCommandOptions & { responseType?: MongoDBResponseConstructor };
+
   constructor(
     parent: Db,
-    public command: Document,
-    public override options: RunCommandOptions & { responseType?: MongoDBResponseConstructor }
+    command: Document,
+    options: RunCommandOptions & { responseType?: MongoDBResponseConstructor }
   ) {
     super(options);
+    this.command = command;
+    this.options = options;
     this.ns = parent.s.namespace.withCollection('$cmd');
   }
 
@@ -62,14 +67,22 @@ export class RunCommandOperation<T = Document> extends AbstractOperation<T> {
 }
 
 export class RunAdminCommandOperation<T = Document> extends AbstractOperation<T> {
+  command: Document;
+  override options: RunCommandOptions & {
+    noResponse?: boolean;
+    bypassPinningCheck?: boolean;
+  };
+
   constructor(
-    public command: Document,
-    public override options: RunCommandOptions & {
+    command: Document,
+    options: RunCommandOptions & {
       noResponse?: boolean;
       bypassPinningCheck?: boolean;
     }
   ) {
     super(options);
+    this.command = command;
+    this.options = options;
     this.ns = new MongoDBNamespace('admin', '$cmd');
   }