mongodb 6.8.2 → 6.9.0

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,6 +30,8 @@ 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;
 
@@ -73,7 +75,11 @@ 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`;
@@ -411,6 +417,15 @@ export interface OpMsgOptions {
   readPreference: ReadPreference;
 }
 
+/** @internal */
+export class DocumentSequence {
+  documents: Document[];
+
+  constructor(documents: Document[]) {
+    this.documents = documents;
+  }
+}
+
 /** @internal */
 export class OpMsgRequest {
   requestId: number;
@@ -480,7 +495,7 @@ export class OpMsgRequest {
 
     let totalLength = header.length;
     const command = this.command;
-    totalLength += this.makeDocumentSegment(buffers, command);
+    totalLength += this.makeSections(buffers, command);
 
     header.writeInt32LE(totalLength, 0); // messageLength
     header.writeInt32LE(this.requestId, 4); // requestID
@@ -490,15 +505,65 @@ export class OpMsgRequest {
     return buffers;
   }
 
-  makeDocumentSegment(buffers: Uint8Array[], document: Document): number {
-    const payloadTypeBuffer = Buffer.alloc(1);
+  /**
+   * 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);
     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;
+  }
 
-    return payloadTypeBuffer.length + documentBuffer.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);
   }
 
   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)) {
+        if (needsRetryableWriteLabel(error, response.maxWireVersion, conn.description.type)) {
           error.addErrorLabel(MongoErrorLabel.RetryableWriteError);
         }
       }
@@ -249,6 +249,7 @@ export async function prepareHandshakeDocument(
 
 /** @public */
 export const LEGAL_TLS_SOCKET_OPTIONS = [
+  'allowPartialTrustChain',
   'ALPNProtocols',
   'ca',
   'cert',
@@ -269,6 +270,8 @@ export const LEGAL_TLS_SOCKET_OPTIONS = [
 
 /** @public */
 export const LEGAL_TCP_SOCKET_OPTIONS = [
+  'autoSelectFamily',
+  'autoSelectFamilyAttemptTimeout',
   'family',
   'hints',
   'localAddress',

package/src/cmap/connection.ts

@@ -333,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);
@@ -603,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, promiseWithResolvers } from '../utils';
+import { type Callback, List, makeCounter, now, promiseWithResolvers } from '../utils';
 import { connect } from './connect';
 import { Connection, type ConnectionEvents, type ConnectionOptions } from './connection';
 import {
@@ -104,6 +104,7 @@ export interface WaitQueueMember {
   reject: (err: AnyError) => void;
   timeout: Timeout;
   [kCancelled]?: boolean;
+  checkoutTime: number;
 }
 
 /** @internal */
@@ -355,6 +356,7 @@ 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)
@@ -369,7 +371,8 @@ export class ConnectionPool extends TypedEventEmitter<ConnectionPoolEvents> {
     const waitQueueMember: WaitQueueMember = {
       resolve,
       reject,
-      timeout
+      timeout,
+      checkoutTime
     };
 
     this[kWaitQueue].push(waitQueueMember);
@@ -385,7 +388,7 @@ export class ConnectionPool extends TypedEventEmitter<ConnectionPoolEvents> {
 
         this.emitAndLog(
           ConnectionPool.CONNECTION_CHECK_OUT_FAILED,
-          new ConnectionCheckOutFailedEvent(this, 'timeout')
+          new ConnectionCheckOutFailedEvent(this, 'timeout', waitQueueMember.checkoutTime)
         );
         const timeoutError = new WaitQueueTimeoutError(
           this.loadBalanced
@@ -629,12 +632,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
@@ -670,7 +673,7 @@ export class ConnectionPool extends TypedEventEmitter<ConnectionPoolEvents> {
         connection.markAvailable();
         this.emitAndLog(
           ConnectionPool.CONNECTION_READY,
-          new ConnectionReadyEvent(this, connection)
+          new ConnectionReadyEvent(this, connection, connectionCreatedTime)
         );
 
         this[kPending]--;
@@ -759,7 +762,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, error)
+          new ConnectionCheckOutFailedEvent(this, reason, waitQueueMember.checkoutTime, error)
         );
         waitQueueMember.timeout.clear();
         this[kWaitQueue].shift();
@@ -780,7 +783,7 @@ export class ConnectionPool extends TypedEventEmitter<ConnectionPoolEvents> {
         this[kCheckedOut].add(connection);
         this.emitAndLog(
           ConnectionPool.CONNECTION_CHECKED_OUT,
-          new ConnectionCheckedOutEvent(this, connection)
+          new ConnectionCheckedOutEvent(this, connection, waitQueueMember.checkoutTime)
         );
         waitQueueMember.timeout.clear();
 
@@ -809,14 +812,19 @@ export class ConnectionPool extends TypedEventEmitter<ConnectionPoolEvents> {
             this.emitAndLog(
               ConnectionPool.CONNECTION_CHECK_OUT_FAILED,
               // TODO(NODE-5192): Remove this cast
-              new ConnectionCheckOutFailedEvent(this, 'connectionError', err as MongoError)
+              new ConnectionCheckOutFailedEvent(
+                this,
+                'connectionError',
+                waitQueueMember.checkoutTime,
+                err as MongoError
+              )
             );
             waitQueueMember.reject(err);
           } else if (connection) {
             this[kCheckedOut].add(connection);
             this.emitAndLog(
               ConnectionPool.CONNECTION_CHECKED_OUT,
-              new ConnectionCheckedOutEvent(this, connection)
+              new ConnectionCheckedOutEvent(this, connection, waitQueueMember.checkoutTime)
             );
             waitQueueMember.resolve(connection);
           }

package/src/cmap/connection_pool_events.ts

@@ -13,6 +13,7 @@ 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';
 
@@ -126,12 +127,25 @@ 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) {
+  constructor(pool: ConnectionPool, connection: Connection, connectionCreatedEventTime: number) {
     super(pool);
+    this.durationMS = now() - connectionCreatedEventTime;
     this.connectionId = connection.id;
   }
 }
@@ -194,14 +208,23 @@ 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;
   }
@@ -217,10 +240,19 @@ 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) {
+  constructor(pool: ConnectionPool, connection: Connection, checkoutTime: number) {
     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-var-requires
+// eslint-disable-next-line @typescript-eslint/no-require-imports
 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 = '7.0';
+export const MAX_SUPPORTED_SERVER_VERSION = '8.0';
 export const MIN_SUPPORTED_WIRE_VERSION = 6;
-export const MAX_SUPPORTED_WIRE_VERSION = 21;
+export const MAX_SUPPORTED_WIRE_VERSION = 25;
 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/shared.ts

@@ -1,6 +1,5 @@
 import { MongoInvalidArgumentError } from '../../error';
-import type { ReadPreferenceLike } from '../../read_preference';
-import { ReadPreference } from '../../read_preference';
+import { ReadPreference, type ReadPreferenceLike } 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,17 +47,18 @@ import {
   FindOneAndUpdateOperation,
   type FindOneAndUpdateOptions
 } from './operations/find_and_modify';
-import type {
-  CreateIndexesOptions,
-  DropIndexesOptions,
-  IndexDescription,
-  IndexDescriptionCompact,
-  IndexDescriptionInfo,
-  IndexInformationOptions,
-  IndexSpecification,
-  ListIndexesOptions
+import {
+  CreateIndexesOperation,
+  type CreateIndexesOptions,
+  type DropIndexesOptions,
+  DropIndexOperation,
+  type IndexDescription,
+  type IndexDescriptionCompact,
+  type IndexDescriptionInfo,
+  type IndexInformationOptions,
+  type IndexSpecification,
+  type ListIndexesOptions
 } from './operations/indexes';
-import { CreateIndexesOperation, DropIndexOperation } from './operations/indexes';
 import {
   InsertManyOperation,
   type InsertManyResult,
@@ -292,7 +293,7 @@ export class Collection<TSchema extends Document = Document> {
    * @param options - Optional settings for the command
    */
   async insertMany(
-    docs: OptionalUnlessRequiredId<TSchema>[],
+    docs: ReadonlyArray<OptionalUnlessRequiredId<TSchema>>,
     options?: BulkWriteOptions
   ): Promise<InsertManyResult<TSchema>> {
     return await executeOperation(
@@ -325,7 +326,7 @@ export class Collection<TSchema extends Document = Document> {
    * @throws MongoDriverError if operations is not an array
    */
   async bulkWrite(
-    operations: AnyBulkWriteOperation<TSchema>[],
+    operations: ReadonlyArray<AnyBulkWriteOperation<TSchema>>,
     options?: BulkWriteOptions
   ): Promise<BulkWriteResult> {
     if (!Array.isArray(operations)) {
@@ -336,7 +337,7 @@ export class Collection<TSchema extends Document = Document> {
       this.client,
       new BulkWriteOperation(
         this as TODO_NODE_3286,
-        operations as TODO_NODE_3286,
+        operations,
         resolveOptions(this, options ?? { ordered: true })
       )
     );
@@ -1121,8 +1122,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,7 +552,6 @@ export function parseOptions(
 
   mongoOptions.metadata = makeClientMetadata(mongoOptions);
 
-  // eslint-disable-next-line github/no-then
   mongoOptions.extendedMetadata = addContainerMetadata(mongoOptions.metadata).then(
     undefined,
     squashError
@@ -740,6 +739,13 @@ export const OPTIONS = {
   autoEncryption: {
     type: 'record'
   },
+  autoSelectFamily: {
+    type: 'boolean',
+    default: true
+  },
+  autoSelectFamilyAttemptTimeout: {
+    type: 'uint'
+  },
   bsonRegExp: {
     type: 'boolean'
   },
@@ -1222,7 +1228,8 @@ export const OPTIONS = {
   // Custom types for modifying core behavior
   connectionType: { type: 'any' },
   srvPoller: { type: 'any' },
-  // Accepted NodeJS Options
+  // Accepted Node.js Options
+  allowPartialTrustChain: { type: 'any' },
   minDHSize: { type: 'any' },
   pskCallback: { type: 'any' },
   secureContext: { type: 'any' },

package/src/constants.ts

@@ -1,3 +1,4 @@
+/* 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';

package/src/cursor/abstract_cursor.ts

@@ -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 { ClientSession, maybeClearPinnedConnection } from '../sessions';
 import { type MongoDBNamespace, squashError } from '../utils';
@@ -125,9 +126,12 @@ export type AbstractCursorEvents = {
 
 /** @public */
 export abstract class AbstractCursor<
-  TSchema = any,
-  CursorEvents extends AbstractCursorEvents = AbstractCursorEvents
-> extends TypedEventEmitter<CursorEvents> {
+    TSchema = any,
+    CursorEvents extends AbstractCursorEvents = AbstractCursorEvents
+  >
+  extends TypedEventEmitter<CursorEvents>
+  implements AsyncDisposable
+{
   /** @internal */
   private cursorId: Long | null;
   /** @internal */
@@ -286,14 +290,25 @@ export abstract class AbstractCursor<
     return !!this.cursorClient.topology?.loadBalanced;
   }
 
+  /**
+   * @beta
+   * @experimental
+   * An alias for {@link AbstractCursor.close|AbstractCursor.close()}.
+   */
+  declare [Symbol.asyncDispose]: () => Promise<void>;
+  /** @internal */
+  async asyncDispose() {
+    await this.close();
+  }
+
   /** Returns current buffered documents length */
   bufferedCount(): number {
     return this.documents?.length ?? 0;
   }
 
   /** Returns current buffered documents */
-  readBufferedDocuments(number?: number): TSchema[] {
-    const bufferedDocs: TSchema[] = [];
+  readBufferedDocuments(number?: number): NonNullable<TSchema>[] {
+    const bufferedDocs: NonNullable<TSchema>[] = [];
     const documentsToRead = Math.min(
       number ?? this.documents?.length ?? 0,
       this.documents?.length ?? 0
@@ -308,6 +323,7 @@ export abstract class AbstractCursor<
 
     return bufferedDocs;
   }
+
   async *[Symbol.asyncIterator](): AsyncGenerator<TSchema, void, void> {
     if (this.closed) {
       return;
@@ -457,6 +473,9 @@ export abstract class AbstractCursor<
     }
   }
 
+  /**
+   * Frees any client-side resources used by the cursor.
+   */
   async close(): Promise<void> {
     await this.cleanup();
   }
@@ -468,13 +487,22 @@ export abstract class AbstractCursor<
    * cursor.rewind() can be used to reset the cursor.
    */
   async toArray(): Promise<TSchema[]> {
-    const array = [];
+    const array: TSchema[] = [];
+    // at the end of the loop (since readBufferedDocuments is called) the buffer will be empty
+    // then, the 'await of' syntax will run a getMore call
     for await (const document of this) {
       array.push(document);
+      const docs = this.readBufferedDocuments();
+      if (this.transform != null) {
+        for (const doc of docs) {
+          array.push(await this.transformDocument(doc));
+        }
+      } else {
+        array.push(...docs);
+      }
     }
     return array;
   }
-
   /**
    * Add a cursor flag to the cursor
    *
@@ -639,7 +667,6 @@ export abstract class AbstractCursor<
       // We only want to end this session if we created it, and it hasn't ended yet
       if (session.explicit === false) {
         if (!session.hasEnded) {
-          // eslint-disable-next-line github/no-then
           session.endSession().then(undefined, squashError);
         }
         this.cursorSession = this.cursorClient.startSession({ owner: this, explicit: false });
@@ -815,7 +842,7 @@ export abstract class AbstractCursor<
   }
 
   /** @internal */
-  private async transformDocument(document: NonNullable<TSchema>): Promise<TSchema> {
+  private async transformDocument(document: NonNullable<TSchema>): Promise<NonNullable<TSchema>> {
     if (this.transform == null) return document;
 
     try {
@@ -865,7 +892,6 @@ class ReadableCursorStream extends Readable {
   }
 
   override _destroy(error: Error | null, callback: (error?: Error | null) => void): void {
-    // eslint-disable-next-line github/no-then
     this._cursor.close().then(
       () => callback(error),
       closeError => callback(closeError)
@@ -878,13 +904,11 @@ class ReadableCursorStream extends Readable {
       return;
     }
 
-    // eslint-disable-next-line github/no-then
     this._cursor.next().then(
       result => {
         if (result == null) {
           this.push(null);
         } else if (this.destroyed) {
-          // eslint-disable-next-line github/no-then
           this._cursor.close().then(undefined, squashError);
         } else {
           if (this.push(result)) {
@@ -900,7 +924,6 @@ class ReadableCursorStream extends Readable {
         //       a client during iteration. Alternatively, we could do the "right" thing and
         //       propagate the error message by removing this special case.
         if (err.message.match(/server is closed/)) {
-          // eslint-disable-next-line github/no-then
           this._cursor.close().then(undefined, squashError);
           return this.push(null);
         }
@@ -927,3 +950,5 @@ class ReadableCursorStream extends Readable {
     );
   }
 }
+
+configureResourceManagement(AbstractCursor.prototype);

package/src/cursor/aggregation_cursor.ts

@@ -5,10 +5,12 @@ import { AggregateOperation, type AggregateOptions } from '../operations/aggrega
 import { executeOperation } from '../operations/execute_operation';
 import type { ClientSession } from '../sessions';
 import type { Sort } from '../sort';
-import type { MongoDBNamespace } from '../utils';
-import { mergeOptions } from '../utils';
-import type { AbstractCursorOptions, InitialCursorResponse } from './abstract_cursor';
-import { AbstractCursor } from './abstract_cursor';
+import { mergeOptions, type MongoDBNamespace } from '../utils';
+import {
+  AbstractCursor,
+  type AbstractCursorOptions,
+  type InitialCursorResponse
+} from './abstract_cursor';
 
 /** @public */
 export interface AggregationCursorOptions extends AbstractCursorOptions, AggregateOptions {}