mongodb 4.3.1 → 4.5.0

package/src/gridfs/upload.ts

@@ -119,15 +119,15 @@ export class GridFSBucketWriteStream extends Writable implements NodeJS.Writable
    * @param callback - Function to call when the chunk was added to the buffer, or if the entire chunk was persisted to MongoDB if this chunk caused a flush.
    * @returns False if this write required flushing a chunk to MongoDB. True otherwise.
    */
-  write(chunk: Buffer | string): boolean;
-  write(chunk: Buffer | string, callback: Callback<void>): boolean;
-  write(chunk: Buffer | string, encoding: BufferEncoding | undefined): boolean;
-  write(
+  override write(chunk: Buffer | string): boolean;
+  override write(chunk: Buffer | string, callback: Callback<void>): boolean;
+  override write(chunk: Buffer | string, encoding: BufferEncoding | undefined): boolean;
+  override write(
     chunk: Buffer | string,
     encoding: BufferEncoding | undefined,
     callback: Callback<void>
   ): boolean;
-  write(
+  override write(
     chunk: Buffer | string,
     encodingOrCallback?: Callback<void> | BufferEncoding,
     callback?: Callback<void>
@@ -172,17 +172,17 @@ export class GridFSBucketWriteStream extends Writable implements NodeJS.Writable
    * @param encoding - Optional encoding for the buffer
    * @param callback - Function to call when all files and chunks have been persisted to MongoDB
    */
-  end(): this;
-  end(chunk: Buffer): this;
-  end(callback: Callback<GridFSFile | void>): this;
-  end(chunk: Buffer, callback: Callback<GridFSFile | void>): this;
-  end(chunk: Buffer, encoding: BufferEncoding): this;
-  end(
+  override end(): this;
+  override end(chunk: Buffer): this;
+  override end(callback: Callback<GridFSFile | void>): this;
+  override end(chunk: Buffer, callback: Callback<GridFSFile | void>): this;
+  override end(chunk: Buffer, encoding: BufferEncoding): this;
+  override end(
     chunk: Buffer,
     encoding: BufferEncoding | undefined,
     callback: Callback<GridFSFile | void>
   ): this;
-  end(
+  override end(
     chunkOrCallback?: Buffer | Callback<GridFSFile | void>,
     encodingOrCallback?: BufferEncoding | Callback<GridFSFile | void>,
     callback?: Callback<GridFSFile | void>

package/src/index.ts

@@ -62,8 +62,10 @@ export {
   MongoServerError,
   MongoServerSelectionError,
   MongoSystemError,
+  MongoTailableCursorError,
   MongoTopologyClosedError,
   MongoTransactionError,
+  MongoUnexpectedServerResponseError,
   MongoWriteConcernError
 } from './error';
 export {
@@ -86,10 +88,12 @@ export {
 
 // enums
 export { BatchType } from './bulk/common';
+export { GSSAPICanonicalizationValue } from './cmap/auth/gssapi';
 export { AuthMechanism } from './cmap/auth/providers';
 export { Compressor } from './cmap/wire_protocol/compression';
 export { CURSOR_FLAGS } from './cursor/abstract_cursor';
 export { AutoEncryptionLoggerLevel } from './deps';
+export { MongoErrorLabel } from './error';
 export { ExplainVerbosity } from './explain';
 export { LoggerLevel } from './logger';
 export { ServerApiVersion } from './mongo_client';
@@ -182,12 +186,17 @@ export type {
   MongoCredentialsOptions
 } from './cmap/auth/mongo_credentials';
 export type {
+  BinMsg,
   GetMore,
   KillCursor,
+  MessageHeader,
   Msg,
   OpGetMoreOptions,
+  OpMsgOptions,
   OpQueryOptions,
+  OpResponseOptions,
   Query,
+  Response,
   WriteProtocolMessageType
 } from './cmap/commands';
 export type { LEGAL_TCP_SOCKET_OPTIONS, LEGAL_TLS_SOCKET_OPTIONS, Stream } from './cmap/connect';
@@ -229,7 +238,7 @@ export type {
 export type { InternalAbstractCursorOptions } from './cursor/abstract_cursor';
 export type { AggregationCursorOptions } from './cursor/aggregation_cursor';
 export type { DbOptions, DbPrivate } from './db';
-export type { AutoEncrypter, AutoEncryptionOptions } from './deps';
+export type { AutoEncrypter, AutoEncryptionOptions, AutoEncryptionTlsOptions } from './deps';
 export type { Encrypter, EncrypterOptions } from './encrypter';
 export type { AnyError, ErrorDescription, MongoNetworkErrorOptions } from './error';
 export type { Explain, ExplainOptions, ExplainVerbosityLike } from './explain';

package/src/mongo_client.ts

@@ -13,12 +13,7 @@ import type { MONGO_CLIENT_EVENTS } from './constants';
 import { Db, DbOptions } from './db';
 import type { AutoEncrypter, AutoEncryptionOptions } from './deps';
 import type { Encrypter } from './encrypter';
-import {
-  AnyError,
-  MongoInvalidArgumentError,
-  MongoNotConnectedError,
-  MongoRuntimeError
-} from './error';
+import { MongoInvalidArgumentError, MongoNotConnectedError } from './error';
 import type { Logger, LoggerLevel } from './logger';
 import { TypedEventEmitter } from './mongo_types';
 import { connect } from './operations/connect';
@@ -75,8 +70,6 @@ export interface PkFactory {
   createPk(): any; // TODO: when js-bson is typed, function should return some BSON type
 }
 
-type CleanUpHandlerFunction = (err?: AnyError, result?: any, opts?: any) => Promise<void>;
-
 /** @public */
 export type SupportedTLSConnectionOptions = Pick<
   TLSConnectionOptions,
@@ -264,7 +257,7 @@ export interface MongoClientOptions extends BSONSerializeOptions, SupportedNodeC
 }
 
 /** @public */
-export type WithSessionCallback = (session: ClientSession) => Promise<any> | void;
+export type WithSessionCallback = (session: ClientSession) => Promise<any>;
 
 /** @internal */
 export interface MongoClientPrivate {
@@ -564,44 +557,29 @@ export class MongoClient extends TypedEventEmitter<MongoClientEvents> {
     optionsOrOperation?: ClientSessionOptions | WithSessionCallback,
     callback?: WithSessionCallback
   ): Promise<void> {
-    let options: ClientSessionOptions = optionsOrOperation as ClientSessionOptions;
-    if (typeof optionsOrOperation === 'function') {
-      callback = optionsOrOperation as WithSessionCallback;
-      options = { owner: Symbol() };
-    }
+    const options = {
+      // Always define an owner
+      owner: Symbol(),
+      // If it's an object inherit the options
+      ...(typeof optionsOrOperation === 'object' ? optionsOrOperation : {})
+    };
+
+    const withSessionCallback =
+      typeof optionsOrOperation === 'function' ? optionsOrOperation : callback;
 
-    if (callback == null) {
+    if (withSessionCallback == null) {
       throw new MongoInvalidArgumentError('Missing required callback parameter');
     }
 
     const session = this.startSession(options);
     const Promise = PromiseProvider.get();
 
-    let cleanupHandler: CleanUpHandlerFunction = ((err, result, opts) => {
-      // prevent multiple calls to cleanupHandler
-      cleanupHandler = () => {
-        // TODO(NODE-3483)
-        throw new MongoRuntimeError('cleanupHandler was called too many times');
-      };
-
-      opts = Object.assign({ throw: true }, opts);
-      session.endSession();
-
-      if (err) {
-        if (opts.throw) throw err;
-        return Promise.reject(err);
-      }
-    }) as CleanUpHandlerFunction;
-
-    try {
-      const result = callback(session);
-      return Promise.resolve(result).then(
-        result => cleanupHandler(undefined, result, undefined),
-        err => cleanupHandler(err, null, { throw: true })
-      );
-    } catch (err) {
-      return cleanupHandler(err, null, { throw: false }) as Promise<void>;
-    }
+    return Promise.resolve()
+      .then(() => withSessionCallback(session))
+      .then(() => {
+        // Do not return the result of callback
+      })
+      .finally(() => session.endSession());
   }
 
   /**
@@ -612,7 +590,7 @@ export class MongoClient extends TypedEventEmitter<MongoClientEvents> {
    * @param pipeline - An array of {@link https://docs.mongodb.com/manual/reference/operator/aggregation-pipeline/|aggregation pipeline stages} through which to pass change stream documents. This allows for filtering (using $match) and manipulating the change stream documents.
    * @param options - Optional settings for the command
    */
-  watch<TSchema = Document>(
+  watch<TSchema extends Document = Document>(
     pipeline: Document[] = [],
     options: ChangeStreamOptions = {}
   ): ChangeStream<TSchema> {

package/src/operations/add_user.ts

@@ -32,7 +32,7 @@ export interface AddUserOptions extends CommandOperationOptions {
 
 /** @internal */
 export class AddUserOperation extends CommandOperation<Document> {
-  options: AddUserOptions;
+  override options: AddUserOptions;
   db: Db;
   username: string;
   password?: string;
@@ -46,7 +46,11 @@ export class AddUserOperation extends CommandOperation<Document> {
     this.options = options ?? {};
   }
 
-  execute(server: Server, session: ClientSession, callback: Callback<Document>): void {
+  override execute(
+    server: Server,
+    session: ClientSession | undefined,
+    callback: Callback<Document>
+  ): void {
     const db = this.db;
     const username = this.username;
     const password = this.password;
@@ -75,7 +79,14 @@ export class AddUserOperation extends CommandOperation<Document> {
       roles = Array.isArray(options.roles) ? options.roles : [options.roles];
     }
 
-    const digestPassword = getTopology(db).lastHello().maxWireVersion >= 7;
+    let topology;
+    try {
+      topology = getTopology(db);
+    } catch (error) {
+      return callback(error);
+    }
+
+    const digestPassword = topology.lastHello().maxWireVersion >= 7;
 
     let userPassword = password;
 

package/src/operations/aggregate.ts

@@ -2,8 +2,7 @@ import type { Document } from '../bson';
 import { MongoInvalidArgumentError } from '../error';
 import type { Server } from '../sdam/server';
 import type { ClientSession } from '../sessions';
-import type { Callback } from '../utils';
-import { maxWireVersion, MongoDBNamespace } from '../utils';
+import { Callback, maxWireVersion, MongoDBNamespace } from '../utils';
 import { CollationOptions, CommandOperation, CommandOperationOptions } from './command';
 import { Aspect, defineAspects, Hint } from './operation';
 
@@ -31,12 +30,13 @@ export interface AggregateOptions extends CommandOperationOptions {
   hint?: Hint;
   /** Map of parameter names and values that can be accessed using $$var (requires MongoDB 5.0). */
   let?: Document;
+
   out?: string;
 }
 
 /** @internal */
 export class AggregateOperation<T = Document> extends CommandOperation<T> {
-  options: AggregateOptions;
+  override options: AggregateOptions;
   target: string | typeof DB_AGGREGATE_COLLECTION;
   pipeline: Document[];
   hasWriteStage: boolean;
@@ -78,7 +78,7 @@ export class AggregateOperation<T = Document> extends CommandOperation<T> {
     }
   }
 
-  get canRetryRead(): boolean {
+  override get canRetryRead(): boolean {
     return !this.hasWriteStage;
   }
 
@@ -86,7 +86,11 @@ export class AggregateOperation<T = Document> extends CommandOperation<T> {
     this.pipeline.push(stage);
   }
 
-  execute(server: Server, session: ClientSession, callback: Callback<T>): void {
+  override execute(
+    server: Server,
+    session: ClientSession | undefined,
+    callback: Callback<T>
+  ): void {
     const options: AggregateOptions = this.options;
     const serverWireVersion = maxWireVersion(server);
     const command: Document = { aggregate: this.target, pipeline: this.pipeline };
@@ -117,6 +121,12 @@ export class AggregateOperation<T = Document> extends CommandOperation<T> {
       command.let = options.let;
     }
 
+    // we check for undefined specifically here to allow falsy values
+    // eslint-disable-next-line no-restricted-syntax
+    if (options.comment !== undefined) {
+      command.comment = options.comment;
+    }
+
     command.cursor = options.cursor || {};
     if (options.batchSize && !this.hasWriteStage) {
       command.cursor.batchSize = options.batchSize;

package/src/operations/bulk_write.ts

@@ -12,7 +12,7 @@ import { AbstractOperation, Aspect, defineAspects } from './operation';
 
 /** @internal */
 export class BulkWriteOperation extends AbstractOperation<BulkWriteResult> {
-  options: BulkWriteOptions;
+  override options: BulkWriteOptions;
   collection: Collection;
   operations: AnyBulkWriteOperation[];
 
@@ -27,7 +27,11 @@ export class BulkWriteOperation extends AbstractOperation<BulkWriteResult> {
     this.operations = operations;
   }
 
-  execute(server: Server, session: ClientSession, callback: Callback<BulkWriteResult>): void {
+  override execute(
+    server: Server,
+    session: ClientSession | undefined,
+    callback: Callback<BulkWriteResult>
+  ): void {
     const coll = this.collection;
     const operations = this.operations;
     const options = { ...this.options, ...this.bsonOptions, readPreference: this.readPreference };

package/src/operations/collections.ts

@@ -11,7 +11,7 @@ export interface CollectionsOptions extends OperationOptions {
 
 /** @internal */
 export class CollectionsOperation extends AbstractOperation<Collection[]> {
-  options: CollectionsOptions;
+  override options: CollectionsOptions;
   db: Db;
 
   constructor(db: Db, options: CollectionsOptions) {
@@ -20,7 +20,11 @@ export class CollectionsOperation extends AbstractOperation<Collection[]> {
     this.db = db;
   }
 
-  execute(server: Server, session: ClientSession, callback: Callback<Collection[]>): void {
+  override execute(
+    server: Server,
+    session: ClientSession | undefined,
+    callback: Callback<Collection[]>
+  ): void {
     const db = this.db;
 
     // Let's get the collection names

package/src/operations/command.ts

@@ -45,8 +45,15 @@ export interface CommandOperationOptions
   /** Collation */
   collation?: CollationOptions;
   maxTimeMS?: number;
-  /** A user-provided comment to attach to this command */
-  comment?: string | Document;
+  /**
+   * Comment to apply to the operation.
+   *
+   * In server versions pre-4.4, 'comment' must be string.  A server
+   * error will be thrown if any other type is provided.
+   *
+   * In server versions 4.4 and above, 'comment' can be any valid BSON type.
+   */
+  comment?: unknown;
   /** Should retry failed writes */
   retryWrites?: boolean;
 
@@ -68,8 +75,7 @@ export interface OperationParent {
 
 /** @internal */
 export abstract class CommandOperation<T> extends AbstractOperation<T> {
-  options: CommandOperationOptions;
-  ns: MongoDBNamespace;
+  override options: CommandOperationOptions;
   readConcern?: ReadConcern;
   writeConcern?: WriteConcern;
   explain?: Explain;
@@ -106,16 +112,25 @@ export abstract class CommandOperation<T> extends AbstractOperation<T> {
     }
   }
 
-  get canRetryWrite(): boolean {
+  override get canRetryWrite(): boolean {
     if (this.hasAspect(Aspect.EXPLAINABLE)) {
       return this.explain == null;
     }
     return true;
   }
 
-  abstract execute(server: Server, session: ClientSession, callback: Callback<T>): void;
-
-  executeCommand(server: Server, session: ClientSession, cmd: Document, callback: Callback): void {
+  abstract override execute(
+    server: Server,
+    session: ClientSession | undefined,
+    callback: Callback<T>
+  ): void;
+
+  executeCommand(
+    server: Server,
+    session: ClientSession | undefined,
+    cmd: Document,
+    callback: Callback
+  ): void {
     // TODO: consider making this a non-enumerable property
     this.server = server;
 

package/src/operations/common_functions.ts

@@ -40,8 +40,15 @@ export function indexInformation(
   // If we specified full information
   const full = options.full == null ? false : options.full;
 
+  let topology;
+  try {
+    topology = getTopology(db);
+  } catch (error) {
+    return callback(error);
+  }
+
   // Did the user destroy the topology
-  if (getTopology(db).isDestroyed()) return callback(new MongoTopologyClosedError());
+  if (topology.isDestroyed()) return callback(new MongoTopologyClosedError());
   // Process all the results from the index command and collection
   function processResults(indexes: any) {
     // Contains all the information

package/src/operations/count.ts

@@ -20,7 +20,7 @@ export interface CountOptions extends CommandOperationOptions {
 
 /** @internal */
 export class CountOperation extends CommandOperation<number> {
-  options: CountOptions;
+  override options: CountOptions;
   collectionName?: string;
   query: Document;
 
@@ -32,7 +32,11 @@ export class CountOperation extends CommandOperation<number> {
     this.query = filter;
   }
 
-  execute(server: Server, session: ClientSession, callback: Callback<number>): void {
+  override execute(
+    server: Server,
+    session: ClientSession | undefined,
+    callback: Callback<number>
+  ): void {
     const options = this.options;
     const cmd: Document = {
       count: this.collectionName,

package/src/operations/count_documents.ts

@@ -32,7 +32,11 @@ export class CountDocumentsOperation extends AggregateOperation<number> {
     super(collection.s.namespace, pipeline, options);
   }
 
-  execute(server: Server, session: ClientSession, callback: Callback<number>): void {
+  override execute(
+    server: Server,
+    session: ClientSession | undefined,
+    callback: Callback<number>
+  ): void {
     super.execute(server, session, (err, result) => {
       if (err || !result) {
         callback(err);

package/src/operations/create_collection.ts

@@ -79,7 +79,7 @@ export interface CreateCollectionOptions extends CommandOperationOptions {
 
 /** @internal */
 export class CreateCollectionOperation extends CommandOperation<Collection> {
-  options: CreateCollectionOptions;
+  override options: CreateCollectionOptions;
   db: Db;
   name: string;
 
@@ -91,7 +91,11 @@ export class CreateCollectionOperation extends CommandOperation<Collection> {
     this.name = name;
   }
 
-  execute(server: Server, session: ClientSession, callback: Callback<Collection>): void {
+  override execute(
+    server: Server,
+    session: ClientSession | undefined,
+    callback: Callback<Collection>
+  ): void {
     const db = this.db;
     const name = this.name;
     const options = this.options;

package/src/operations/delete.ts

@@ -12,8 +12,6 @@ import { Aspect, defineAspects, Hint } from './operation';
 export interface DeleteOptions extends CommandOperationOptions, WriteConcernOptions {
   /** If true, when an insert fails, don't execute the remaining writes. If false, continue with remaining inserts when one fails. */
   ordered?: boolean;
-  /** A user-provided comment to attach to this command */
-  comment?: string | Document;
   /** Specifies the collation to use for the operation */
   collation?: CollationOptions;
   /** Specify that the update query should only consider plans using the hinted index */
@@ -43,13 +41,11 @@ export interface DeleteStatement {
   collation?: CollationOptions;
   /** A document or string that specifies the index to use to support the query predicate. */
   hint?: Hint;
-  /** A user-provided comment to attach to this command */
-  comment?: string | Document;
 }
 
 /** @internal */
 export class DeleteOperation extends CommandOperation<Document> {
-  options: DeleteOptions;
+  override options: DeleteOptions;
   statements: DeleteStatement[];
 
   constructor(ns: MongoDBNamespace, statements: DeleteStatement[], options: DeleteOptions) {
@@ -59,7 +55,7 @@ export class DeleteOperation extends CommandOperation<Document> {
     this.statements = statements;
   }
 
-  get canRetryWrite(): boolean {
+  override get canRetryWrite(): boolean {
     if (super.canRetryWrite === false) {
       return false;
     }
@@ -67,7 +63,7 @@ export class DeleteOperation extends CommandOperation<Document> {
     return this.statements.every(op => (op.limit != null ? op.limit > 0 : true));
   }
 
-  execute(server: Server, session: ClientSession, callback: Callback): void {
+  override execute(server: Server, session: ClientSession | undefined, callback: Callback): void {
     const options = this.options ?? {};
     const ordered = typeof options.ordered === 'boolean' ? options.ordered : true;
     const command: Document = {
@@ -80,6 +76,12 @@ export class DeleteOperation extends CommandOperation<Document> {
       command.let = options.let;
     }
 
+    // we check for undefined specifically here to allow falsy values
+    // eslint-disable-next-line no-restricted-syntax
+    if (options.comment !== undefined) {
+      command.comment = options.comment;
+    }
+
     if (options.explain != null && maxWireVersion(server) < 3) {
       return callback
         ? callback(
@@ -111,7 +113,11 @@ export class DeleteOneOperation extends DeleteOperation {
     super(collection.s.namespace, [makeDeleteStatement(filter, { ...options, limit: 1 })], options);
   }
 
-  execute(server: Server, session: ClientSession, callback: Callback<DeleteResult>): void {
+  override execute(
+    server: Server,
+    session: ClientSession | undefined,
+    callback: Callback<DeleteResult>
+  ): void {
     super.execute(server, session, (err, res) => {
       if (err || res == null) return callback(err);
       if (res.code) return callback(new MongoServerError(res));
@@ -131,7 +137,11 @@ export class DeleteManyOperation extends DeleteOperation {
     super(collection.s.namespace, [makeDeleteStatement(filter, options)], options);
   }
 
-  execute(server: Server, session: ClientSession, callback: Callback<DeleteResult>): void {
+  override execute(
+    server: Server,
+    session: ClientSession | undefined,
+    callback: Callback<DeleteResult>
+  ): void {
     super.execute(server, session, (err, res) => {
       if (err || res == null) return callback(err);
       if (res.code) return callback(new MongoServerError(res));
@@ -167,10 +177,6 @@ export function makeDeleteStatement(
     op.hint = options.hint;
   }
 
-  if (options.comment) {
-    op.comment = options.comment;
-  }
-
   return op;
 }
 

package/src/operations/distinct.ts

@@ -15,7 +15,7 @@ export type DistinctOptions = CommandOperationOptions;
  * @internal
  */
 export class DistinctOperation extends CommandOperation<any[]> {
-  options: DistinctOptions;
+  override options: DistinctOptions;
   collection: Collection;
   /** Field of the document to find distinct values for. */
   key: string;
@@ -39,7 +39,11 @@ export class DistinctOperation extends CommandOperation<any[]> {
     this.query = query;
   }
 
-  execute(server: Server, session: ClientSession, callback: Callback<any[]>): void {
+  override execute(
+    server: Server,
+    session: ClientSession | undefined,
+    callback: Callback<any[]>
+  ): void {
     const coll = this.collection;
     const key = this.key;
     const query = this.query;

package/src/operations/drop.ts

@@ -10,7 +10,7 @@ export type DropCollectionOptions = CommandOperationOptions;
 
 /** @internal */
 export class DropCollectionOperation extends CommandOperation<boolean> {
-  options: DropCollectionOptions;
+  override options: DropCollectionOptions;
   name: string;
 
   constructor(db: Db, name: string, options: DropCollectionOptions) {
@@ -19,7 +19,11 @@ export class DropCollectionOperation extends CommandOperation<boolean> {
     this.name = name;
   }
 
-  execute(server: Server, session: ClientSession, callback: Callback<boolean>): void {
+  override execute(
+    server: Server,
+    session: ClientSession | undefined,
+    callback: Callback<boolean>
+  ): void {
     super.executeCommand(server, session, { drop: this.name }, (err, result) => {
       if (err) return callback(err);
       if (result.ok) return callback(undefined, true);
@@ -33,13 +37,17 @@ export type DropDatabaseOptions = CommandOperationOptions;
 
 /** @internal */
 export class DropDatabaseOperation extends CommandOperation<boolean> {
-  options: DropDatabaseOptions;
+  override options: DropDatabaseOptions;
 
   constructor(db: Db, options: DropDatabaseOptions) {
     super(db, options);
     this.options = options;
   }
-  execute(server: Server, session: ClientSession, callback: Callback<boolean>): void {
+  override execute(
+    server: Server,
+    session: ClientSession | undefined,
+    callback: Callback<boolean>
+  ): void {
     super.executeCommand(server, session, { dropDatabase: 1 }, (err, result) => {
       if (err) return callback(err);
       if (result.ok) return callback(undefined, true);

package/src/operations/estimated_document_count.ts

@@ -19,7 +19,7 @@ export interface EstimatedDocumentCountOptions extends CommandOperationOptions {
 
 /** @internal */
 export class EstimatedDocumentCountOperation extends CommandOperation<number> {
-  options: EstimatedDocumentCountOptions;
+  override options: EstimatedDocumentCountOptions;
   collectionName: string;
 
   constructor(collection: Collection, options: EstimatedDocumentCountOptions = {}) {
@@ -28,7 +28,11 @@ export class EstimatedDocumentCountOperation extends CommandOperation<number> {
     this.collectionName = collection.collectionName;
   }
 
-  execute(server: Server, session: ClientSession, callback: Callback<number>): void {
+  override execute(
+    server: Server,
+    session: ClientSession | undefined,
+    callback: Callback<number>
+  ): void {
     if (maxWireVersion(server) < 12) {
       return this.executeLegacy(server, session, callback);
     }
@@ -50,7 +54,11 @@ export class EstimatedDocumentCountOperation extends CommandOperation<number> {
     });
   }
 
-  executeLegacy(server: Server, session: ClientSession, callback: Callback<number>): void {
+  executeLegacy(
+    server: Server,
+    session: ClientSession | undefined,
+    callback: Callback<number>
+  ): void {
     const cmd: Document = { count: this.collectionName };
 
     if (typeof this.options.maxTimeMS === 'number') {