mongodb 6.20.0 → 7.0.0-dev.20251107.sha.5db818c2

package/src/cmap/auth/mongodb_aws.ts

@@ -11,9 +11,7 @@ import { type AuthContext, AuthProvider } from './auth_provider';
 import {
   type AWSCredentialProvider,
   AWSSDKCredentialProvider,
-  type AWSTempCredentials,
-  AWSTemporaryCredentialProvider,
-  LegacyAWSTemporaryCredentialProvider
+  type AWSTempCredentials
 } from './aws_temporary_credentials';
 import { MongoCredentials } from './mongo_credentials';
 import { AuthMechanism } from './providers';
@@ -34,16 +32,11 @@ interface AWSSaslContinuePayload {
 }
 
 export class MongoDBAWS extends AuthProvider {
-  private credentialFetcher: AWSTemporaryCredentialProvider;
-  private credentialProvider?: AWSCredentialProvider;
+  private credentialFetcher: AWSSDKCredentialProvider;
 
   constructor(credentialProvider?: AWSCredentialProvider) {
     super();
-
-    this.credentialProvider = credentialProvider;
-    this.credentialFetcher = AWSTemporaryCredentialProvider.isAWSSDKInstalled
-      ? new AWSSDKCredentialProvider(credentialProvider)
-      : new LegacyAWSTemporaryCredentialProvider();
+    this.credentialFetcher = new AWSSDKCredentialProvider(credentialProvider);
   }
 
   override async auth(authContext: AuthContext): Promise<void> {
@@ -63,12 +56,10 @@ export class MongoDBAWS extends AuthProvider {
       );
     }
 
-    if (!authContext.credentials.username) {
-      authContext.credentials = await makeTempCredentials(
-        authContext.credentials,
-        this.credentialFetcher
-      );
-    }
+    authContext.credentials = await makeTempCredentials(
+      authContext.credentials,
+      this.credentialFetcher
+    );
 
     const { credentials } = authContext;
 
@@ -162,7 +153,7 @@ export class MongoDBAWS extends AuthProvider {
 
 async function makeTempCredentials(
   credentials: MongoCredentials,
-  awsCredentialFetcher: AWSTemporaryCredentialProvider
+  awsCredentialFetcher: AWSSDKCredentialProvider
 ): Promise<MongoCredentials> {
   function makeMongoCredentialsFromAWSTemp(creds: AWSTempCredentials) {
     // The AWS session token (creds.Token) may or may not be set.

package/src/cmap/auth/providers.ts

@@ -1,7 +1,6 @@
 /** @public */
 export const AuthMechanism = Object.freeze({
   MONGODB_AWS: 'MONGODB-AWS',
-  MONGODB_CR: 'MONGODB-CR',
   MONGODB_DEFAULT: 'DEFAULT',
   MONGODB_GSSAPI: 'GSSAPI',
   MONGODB_PLAIN: 'PLAIN',

package/src/cmap/connect.ts

@@ -222,7 +222,7 @@ export async function prepareHandshakeDocument(
   const options = authContext.options;
   const compressors = options.compressors ? options.compressors : [];
   const { serverApi } = authContext.connection;
-  const clientMetadata: Document = await options.extendedMetadata;
+  const clientMetadata: Document = await options.metadata;
 
   const handshakeDoc: HandshakeDocument = {
     [serverApi?.version || options.loadBalanced === true ? 'hello' : LEGACY_HELLO_COMMAND]: 1,

package/src/cmap/connection.ts

@@ -22,7 +22,6 @@ import {
 import {
   MongoCompatibilityError,
   MONGODB_ERROR_CODES,
-  MongoMissingDependencyError,
   MongoNetworkError,
   MongoNetworkTimeoutError,
   MongoOperationTimeoutError,
@@ -91,7 +90,6 @@ export interface CommandOptions extends BSONSerializeOptions {
   /** Session to use for the operation */
   session?: ClientSession;
   documentsReturnedIn?: string;
-  noResponse?: boolean;
   omitMaxTimeMS?: boolean;
 
   // TODO(NODE-2802): Currently the CommandOptions take a property willRetryWrite which is a hint
@@ -139,10 +137,10 @@ export interface ConnectionOptions
   tls: boolean;
   noDelay?: boolean;
   socketTimeoutMS?: number;
+  /** @internal */
   cancellationToken?: CancellationToken;
-  metadata: ClientMetadata;
   /** @internal */
-  extendedMetadata: Promise<Document>;
+  metadata: Promise<ClientMetadata>;
   /** @internal */
   mongoLogger?: MongoLogger | undefined;
 }
@@ -468,7 +466,7 @@ export class Connection extends TypedEventEmitter<ConnectionEvents> {
         signal: options.signal
       });
 
-      if (options.noResponse || message.moreToCome) {
+      if (message.moreToCome) {
         yield MongoDBResponse.empty;
         return;
       }
@@ -568,11 +566,7 @@ export class Connection extends TypedEventEmitter<ConnectionEvents> {
             new CommandSucceededEvent(
               this,
               message,
-              options.noResponse
-                ? undefined
-                : message.moreToCome
-                  ? { ok: 1 }
-                  : (object ??= document.toObject(bsonOptions)),
+              message.moreToCome ? { ok: 1 } : (object ??= document.toObject(bsonOptions)),
               started,
               this.description.serverConnectionId
             )
@@ -715,7 +709,15 @@ export class Connection extends TypedEventEmitter<ConnectionEvents> {
       }
     }
 
-    if (this.socket.write(buffer)) return;
+    try {
+      if (this.socket.write(buffer)) return;
+    } catch (writeError) {
+      const networkError = new MongoNetworkError('unexpected error writing to socket', {
+        cause: writeError
+      });
+      this.onError(networkError);
+      throw networkError;
+    }
 
     const drainEvent = once<void>(this.socket, 'drain', options);
     const timeout = options?.timeoutContext?.timeoutForSocketWrite;
@@ -868,11 +870,7 @@ export class CryptoConnection extends Connection {
   ): Promise<Document> {
     const { autoEncrypter } = this;
     if (!autoEncrypter) {
-      // TODO(NODE-6065): throw a MongoRuntimeError in Node V7
-      // @ts-expect-error No cause provided because there is no underlying error.
-      throw new MongoMissingDependencyError('No AutoEncrypter available for encryption', {
-        dependencyName: 'n/a'
-      });
+      throw new MongoRuntimeError('No AutoEncrypter available for encryption');
     }
 
     const serverWireVersion = maxWireVersion(this);

package/src/cmap/connection_pool.ts

@@ -97,15 +97,6 @@ export const PoolState = Object.freeze({
 
 type PoolState = (typeof PoolState)[keyof typeof PoolState];
 
-/**
- * @public
- * @deprecated This interface is deprecated and will be removed in a future release as it is not used
- * in the driver
- */
-export interface CloseOptions {
-  force?: boolean;
-}
-
 /** @public */
 export type ConnectionPoolEvents = {
   connectionPoolCreated(event: ConnectionPoolCreatedEvent): void;
@@ -610,9 +601,9 @@ 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.
+    // Note that metadata may have changed on the client but have
+    // been frozen here, so we pull the metadata promise always from the client
+    // no matter what options were set at the construction of the pool.
     const connectOptions: ConnectionOptions = {
       ...this.options,
       id: this.connectionCounter.next().value,
@@ -620,7 +611,7 @@ export class ConnectionPool extends TypedEventEmitter<ConnectionPoolEvents> {
       cancellationToken: this.cancellationToken,
       mongoLogger: this.mongoLogger,
       authProviders: this.server.topology.client.s.authProviders,
-      extendedMetadata: this.server.topology.client.options.extendedMetadata
+      metadata: this.server.topology.client.options.metadata
     };
 
     this.pending++;

package/src/cmap/errors.ts

@@ -56,7 +56,7 @@ export class PoolClearedError extends MongoNetworkError {
     super(errorMessage, pool.serverError ? { cause: pool.serverError } : undefined);
     this.address = pool.address;
 
-    this.addErrorLabel(MongoErrorLabel.PoolRequstedRetry);
+    this.addErrorLabel(MongoErrorLabel.PoolRequestedRetry);
   }
 
   override get name(): string {

package/src/cmap/handshake/client_metadata.ts

@@ -27,8 +27,7 @@ export function isDriverInfoEqual(info1: DriverInfo, info2: DriverInfo): boolean
 }
 
 /**
- * @public
- * @deprecated This interface will be made internal in the next major release.
+ * @internal
  * @see https://github.com/mongodb/specifications/blob/master/source/mongodb-handshake/handshake.md#hello-command
  */
 export interface ClientMetadata {
@@ -48,27 +47,17 @@ export interface ClientMetadata {
   };
   /** FaaS environment information */
   env?: {
-    name: 'aws.lambda' | 'gcp.func' | 'azure.func' | 'vercel';
+    name?: 'aws.lambda' | 'gcp.func' | 'azure.func' | 'vercel';
     timeout_sec?: Int32;
     memory_mb?: Int32;
     region?: string;
-    url?: string;
+    container?: {
+      runtime?: string;
+      orchestrator?: string;
+    };
   };
 }
 
-/**
- * @public
- * @deprecated This interface will be made internal in the next major release.
- */
-export interface ClientMetadataOptions {
-  driverInfo?: {
-    name?: string;
-    version?: string;
-    platform?: string;
-  };
-  appName?: string;
-}
-
 /** @internal */
 export class LimitedSizeDocument {
   private document = new Map();
@@ -116,10 +105,10 @@ type MakeClientMetadataOptions = Pick<MongoOptions, 'appName'>;
  * 3. Omit the `env` document entirely.
  * 4. Truncate `platform`. -- special we do not truncate this field
  */
-export function makeClientMetadata(
+export async function makeClientMetadata(
   driverInfoList: DriverInfo[],
   { appName = '' }: MakeClientMetadataOptions
-): ClientMetadata {
+): Promise<ClientMetadata> {
   const metadataDocument = new LimitedSizeDocument(512);
 
   // Add app name first, it must be sent
@@ -191,19 +180,21 @@ export function makeClientMetadata(
       }
     }
   }
-  return metadataDocument.toObject() as ClientMetadata;
+  return await addContainerMetadata(metadataDocument.toObject() as ClientMetadata);
 }
 
 let dockerPromise: Promise<boolean>;
+type ContainerMetadata = NonNullable<NonNullable<ClientMetadata['env']>['container']>;
 /** @internal */
-async function getContainerMetadata() {
-  const containerMetadata: Record<string, any> = {};
+async function getContainerMetadata(): Promise<ContainerMetadata> {
   dockerPromise ??= fileIsAccessible('/.dockerenv');
   const isDocker = await dockerPromise;
 
   const { KUBERNETES_SERVICE_HOST = '' } = process.env;
   const isKubernetes = KUBERNETES_SERVICE_HOST.length > 0 ? true : false;
 
+  const containerMetadata: ContainerMetadata = {};
+
   if (isDocker) containerMetadata.runtime = 'docker';
   if (isKubernetes) containerMetadata.orchestrator = 'kubernetes';
 
@@ -215,15 +206,16 @@ async function getContainerMetadata() {
  * Re-add each metadata value.
  * Attempt to add new env container metadata, but keep old data if it does not fit.
  */
-export async function addContainerMetadata(
-  originalMetadata: ClientMetadata
-): Promise<ClientMetadata> {
+async function addContainerMetadata(originalMetadata: ClientMetadata): Promise<ClientMetadata> {
   const containerMetadata = await getContainerMetadata();
   if (Object.keys(containerMetadata).length === 0) return originalMetadata;
 
   const extendedMetadata = new LimitedSizeDocument(512);
 
-  const extendedEnvMetadata = { ...originalMetadata?.env, container: containerMetadata };
+  const extendedEnvMetadata: NonNullable<ClientMetadata['env']> = {
+    ...originalMetadata?.env,
+    container: containerMetadata
+  };
 
   for (const [key, val] of Object.entries(originalMetadata)) {
     if (key !== 'env') {

package/src/cmap/wire_protocol/constants.ts

@@ -1,5 +1,7 @@
 export const MIN_SUPPORTED_SERVER_VERSION = '4.2';
 export const MAX_SUPPORTED_SERVER_VERSION = '8.2';
+export const MIN_SUPPORTED_SNAPSHOT_READS_WIRE_VERSION = 13;
+export const MIN_SUPPORTED_SNAPSHOT_READS_SERVER_VERSION = '5.0';
 export const MIN_SUPPORTED_WIRE_VERSION = 8;
 export const MAX_SUPPORTED_WIRE_VERSION = 27;
 export const MIN_SUPPORTED_QE_WIRE_VERSION = 21;

package/src/cmap/wire_protocol/on_data.ts

@@ -49,7 +49,7 @@ export function onData(
   /** Set to true only after event listeners have been removed. */
   let finished = false;
 
-  const iterator: AsyncGenerator<Buffer> = {
+  const iterator: AsyncGenerator<Buffer> & AsyncDisposable = {
     next() {
       // First, we consume all unread events
       const value = unconsumedEvents.shift();
@@ -89,7 +89,6 @@ export function onData(
       return this;
     },
 
-    // Note this should currently not be used, but is required by the AsyncGenerator interface.
     async [Symbol.asyncDispose]() {
       await closeHandler();
     }

package/src/collection.ts

@@ -546,7 +546,7 @@ export class Collection<TSchema extends Document = Document> {
     // Explicitly set the limit to 1 and singleBatch to true for all commands, per the spec.
     // noCursorTimeout must be unset as well as batchSize.
     // See: https://github.com/mongodb/specifications/blob/master/source/crud/crud.md#findone-api-details
-    const { batchSize: _batchSize, noCursorTimeout: _noCursorTimeout, ...opts } = options;
+    const { ...opts } = options;
     opts.singleBatch = true;
     const cursor = this.find(filter, opts).limit(1);
     const result = await cursor.next();

package/src/connection_string.ts

@@ -7,12 +7,7 @@ import { MongoCredentials } from './cmap/auth/mongo_credentials';
 import { AUTH_MECHS_AUTH_SRC_EXTERNAL, AuthMechanism } from './cmap/auth/providers';
 import { Compressor, type CompressorName } from './cmap/wire_protocol/compression';
 import { Encrypter } from './encrypter';
-import {
-  MongoAPIError,
-  MongoInvalidArgumentError,
-  MongoMissingCredentialsError,
-  MongoParseError
-} from './error';
+import { MongoAPIError, MongoInvalidArgumentError, MongoParseError } from './error';
 import {
   MongoClient,
   type MongoClientOptions,
@@ -417,10 +412,18 @@ export function parseOptions(
       });
     }
 
-    if (isAws && mongoOptions.credentials.username && !mongoOptions.credentials.password) {
-      throw new MongoMissingCredentialsError(
-        `When using ${mongoOptions.credentials.mechanism} password must be set when a username is specified`
-      );
+    if (isAws) {
+      const { username, password } = mongoOptions.credentials;
+      if (username || password) {
+        throw new MongoAPIError(
+          'username and password cannot be provided when using MONGODB-AWS. Credentials must be provided in a manner that can be read by the AWS SDK.'
+        );
+      }
+      if (mongoOptions.credentials.mechanismProperties.AWS_SESSION_TOKEN) {
+        throw new MongoAPIError(
+          'AWS_SESSION_TOKEN cannot be provided when using MONGODB-AWS. Credentials must be provided in a manner that can be read by the AWS SDK.'
+        );
+      }
     }
 
     mongoOptions.credentials.validate();
@@ -1283,16 +1286,6 @@ export const OPTIONS = {
   secureProtocol: { type: 'any' },
   index: { type: 'any' },
   // Legacy options from v3 era
-  useNewUrlParser: {
-    type: 'boolean',
-    deprecated:
-      'useNewUrlParser has no effect since Node.js Driver version 4.0.0 and will be removed in the next major version'
-  } as OptionDescriptor,
-  useUnifiedTopology: {
-    type: 'boolean',
-    deprecated:
-      'useUnifiedTopology has no effect since Node.js Driver version 4.0.0 and will be removed in the next major version'
-  } as OptionDescriptor,
   __skipPingOnConnect: { type: 'boolean' }
 } as Record<keyof MongoClientOptions, OptionDescriptor>;
 

package/src/cursor/abstract_cursor.ts

@@ -1,4 +1,4 @@
-import { Readable, Transform } from 'stream';
+import { Readable } from 'stream';
 
 import { type BSONSerializeOptions, type Document, Long, pluckBSONSerializeOptions } from '../bson';
 import { type OnDemandDocumentDeserializeOptions } from '../cmap/wire_protocol/on_demand/document';
@@ -18,7 +18,6 @@ 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';
@@ -59,12 +58,6 @@ export const CURSOR_FLAGS = [
   'partial'
 ] as const;
 
-/** @public */
-export interface CursorStreamOptions {
-  /** A transformation method applied to each document emitted by the stream */
-  transform?(this: void, doc: Document): Document;
-}
-
 /** @public */
 export type CursorFlag = (typeof CURSOR_FLAGS)[number];
 
@@ -437,13 +430,10 @@ export abstract class AbstractCursor<
   }
 
   /**
-   * @beta
    * @experimental
    * An alias for {@link AbstractCursor.close|AbstractCursor.close()}.
    */
-  declare [Symbol.asyncDispose]: () => Promise<void>;
-  /** @internal */
-  async asyncDispose() {
+  async [Symbol.asyncDispose]() {
     await this.close();
   }
 
@@ -523,7 +513,7 @@ export abstract class AbstractCursor<
     }
   }
 
-  stream(options?: CursorStreamOptions): Readable & AsyncIterable<TSchema> {
+  stream(): Readable & AsyncIterable<TSchema> {
     const readable = new ReadableCursorStream(this);
     const abortListener = addAbortListener(this.signal, function () {
       readable.destroy(this.reason);
@@ -532,31 +522,6 @@ 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;
   }
 
@@ -701,7 +666,11 @@ export abstract class AbstractCursor<
           array.push(await this.transformDocument(doc));
         }
       } else {
-        array.push(...docs);
+        // 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);
+        }
       }
     }
     return array;
@@ -893,7 +862,7 @@ export abstract class AbstractCursor<
   ): Promise<InitialCursorResponse>;
 
   /** @internal */
-  async getMore(batchSize: number): Promise<CursorResponse> {
+  async getMore(): Promise<CursorResponse> {
     if (this.cursorId == null) {
       throw new MongoRuntimeError(
         'Unexpected null cursor id. A cursor creating command should have set this'
@@ -910,11 +879,10 @@ export abstract class AbstractCursor<
         'Unexpected null session. A cursor creating command should have set this'
       );
     }
-
     const getMoreOptions = {
       ...this.cursorOptions,
       session: this.cursorSession,
-      batchSize
+      batchSize: this.cursorOptions.batchSize
     };
 
     const getMoreOperation = new GetMoreOperation(
@@ -987,14 +955,11 @@ 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 need to call getMore
-    const batchSize = this.cursorOptions.batchSize || 1000;
-
+    // Otherwise, run a getMore
     try {
-      const response = await this.getMore(batchSize);
+      const response = await this.getMore();
       this.cursorId = response.id;
       this.documents = response;
     } catch (error) {
@@ -1223,8 +1188,6 @@ 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(batchSize: number): Promise<CursorResponse> {
-    const response = await super.getMore(batchSize);
+  override async getMore(): Promise<CursorResponse> {
+    const response = await super.getMore();
 
     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, squashError } from '../utils';
+import { emitWarningOnce, mergeOptions, type MongoDBNamespace, noop, squashError } from '../utils';
 import { type InitialCursorResponse } from './abstract_cursor';
 import { ExplainableCursor } from './explainable_cursor';
 
@@ -98,37 +98,50 @@ export class FindCursor<TSchema = any> extends ExplainableCursor<TSchema> {
   }
 
   /** @internal */
-  override async getMore(batchSize: number): Promise<CursorResponse> {
+  override async getMore(): Promise<CursorResponse> {
     const numReturned = this.numReturned;
-    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;
+    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);
       }
+      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;
+      };
     }
 
-    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;
+    try {
+      const response = await super.getMore();
 
-    return response;
+      this.numReturned = this.numReturned + response.batchSize;
+
+      return response;
+    } finally {
+      cleanup?.();
+    }
   }
 
   /**

package/src/cursor/run_command_cursor.ts

@@ -159,7 +159,7 @@ export class RunCommandCursor extends AbstractCursor {
   }
 
   /** @internal */
-  override async getMore(_batchSize: number): Promise<CursorResponse> {
+  override async getMore(): 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',
-  PoolRequstedRetry: 'PoolRequstedRetry',
+  PoolRequestedRetry: 'PoolRequestedRetry',
   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.PoolRequstedRetry)
+    error.hasErrorLabel(MongoErrorLabel.PoolRequestedRetry)
   );
 }