mongodb 4.0.0 → 4.1.2

package/src/gridfs/download.ts

@@ -1,5 +1,10 @@
 import { Readable } from 'stream';
-import { AnyError, MongoDriverError } from '../error';
+import {
+  MongoRuntimeError,
+  MongoGridFSChunkError,
+  MongoGridFSStreamError,
+  MongoInvalidArgumentError
+} from '../error';
 import type { Document } from '../bson';
 import type { FindOptions } from '../operations/find';
 import type { Sort } from '../sort';
@@ -68,7 +73,7 @@ export interface GridFSBucketReadStreamPrivate {
  * Do not instantiate this class directly. Use `openDownloadStream()` instead.
  * @public
  */
-export class GridFSBucketReadStream extends Readable {
+export class GridFSBucketReadStream extends Readable implements NodeJS.ReadableStream {
   /** @internal */
   s: GridFSBucketReadStreamPrivate;
 
@@ -195,7 +200,7 @@ export class GridFSBucketReadStream extends Readable {
 
 function throwIfInitialized(stream: GridFSBucketReadStream): void {
   if (stream.s.init) {
-    throw new MongoDriverError('Options cannot be changed after the stream is initialized');
+    throw new MongoGridFSStreamError('Options cannot be changed after the stream is initialized');
   }
 }
 
@@ -209,7 +214,8 @@ function doRead(stream: GridFSBucketReadStream): void {
       return;
     }
     if (error) {
-      return __handleError(stream, error);
+      stream.emit(GridFSBucketReadStream.ERROR, error);
+      return;
     }
     if (!doc) {
       stream.push(null);
@@ -218,7 +224,7 @@ function doRead(stream: GridFSBucketReadStream): void {
         if (!stream.s.cursor) return;
         stream.s.cursor.close(error => {
           if (error) {
-            __handleError(stream, error);
+            stream.emit(GridFSBucketReadStream.ERROR, error);
             return;
           }
 
@@ -234,31 +240,38 @@ function doRead(stream: GridFSBucketReadStream): void {
     const bytesRemaining = stream.s.file.length - stream.s.bytesRead;
     const expectedN = stream.s.expected++;
     const expectedLength = Math.min(stream.s.file.chunkSize, bytesRemaining);
-    let errmsg: string;
     if (doc.n > expectedN) {
-      errmsg = 'ChunkIsMissing: Got unexpected n: ' + doc.n + ', expected: ' + expectedN;
-      return __handleError(stream, new MongoDriverError(errmsg));
+      return stream.emit(
+        GridFSBucketReadStream.ERROR,
+        new MongoGridFSChunkError(
+          `ChunkIsMissing: Got unexpected n: ${doc.n}, expected: ${expectedN}`
+        )
+      );
     }
 
     if (doc.n < expectedN) {
-      errmsg = 'ExtraChunk: Got unexpected n: ' + doc.n + ', expected: ' + expectedN;
-      return __handleError(stream, new MongoDriverError(errmsg));
+      return stream.emit(
+        GridFSBucketReadStream.ERROR,
+        new MongoGridFSChunkError(`ExtraChunk: Got unexpected n: ${doc.n}, expected: ${expectedN}`)
+      );
     }
 
     let buf = Buffer.isBuffer(doc.data) ? doc.data : doc.data.buffer;
 
     if (buf.byteLength !== expectedLength) {
       if (bytesRemaining <= 0) {
-        errmsg = 'ExtraChunk: Got unexpected n: ' + doc.n;
-        return __handleError(stream, new MongoDriverError(errmsg));
+        return stream.emit(
+          GridFSBucketReadStream.ERROR,
+          new MongoGridFSChunkError(`ExtraChunk: Got unexpected n: ${doc.n}`)
+        );
       }
 
-      errmsg =
-        'ChunkIsWrongSize: Got unexpected length: ' +
-        buf.byteLength +
-        ', expected: ' +
-        expectedLength;
-      return __handleError(stream, new MongoDriverError(errmsg));
+      return stream.emit(
+        GridFSBucketReadStream.ERROR,
+        new MongoGridFSChunkError(
+          `ChunkIsWrongSize: Got unexpected length: ${buf.byteLength}, expected: ${expectedLength}`
+        )
+      );
     }
 
     stream.s.bytesRead += buf.byteLength;
@@ -305,17 +318,18 @@ function init(stream: GridFSBucketReadStream): void {
 
   stream.s.files.findOne(stream.s.filter, findOneOptions, (error, doc) => {
     if (error) {
-      return __handleError(stream, error);
+      return stream.emit(GridFSBucketReadStream.ERROR, error);
     }
 
     if (!doc) {
       const identifier = stream.s.filter._id
         ? stream.s.filter._id.toString()
         : stream.s.filter.filename;
-      const errmsg = 'FileNotFound: file ' + identifier + ' was not found';
-      const err = new MongoDriverError(errmsg);
+      const errmsg = `FileNotFound: file ${identifier} was not found`;
+      // TODO(NODE-3483)
+      const err = new MongoRuntimeError(errmsg);
       err.code = 'ENOENT'; // TODO: NODE-3338 set property as part of constructor
-      return __handleError(stream, err);
+      return stream.emit(GridFSBucketReadStream.ERROR, err);
     }
 
     // If document is empty, kill the stream immediately and don't
@@ -336,7 +350,7 @@ function init(stream: GridFSBucketReadStream): void {
     try {
       stream.s.bytesToSkip = handleStartOption(stream, doc, stream.s.options);
     } catch (error) {
-      return __handleError(stream, error);
+      return stream.emit(GridFSBucketReadStream.ERROR, error);
     }
 
     const filter: Document = { files_id: doc._id };
@@ -362,7 +376,7 @@ function init(stream: GridFSBucketReadStream): void {
     try {
       stream.s.bytesToTrim = handleEndOption(stream, doc, stream.s.cursor, stream.s.options);
     } catch (error) {
-      return __handleError(stream, error);
+      return stream.emit(GridFSBucketReadStream.ERROR, error);
     }
 
     stream.emit(GridFSBucketReadStream.FILE, doc);
@@ -391,26 +405,16 @@ function handleStartOption(
 ): number {
   if (options && options.start != null) {
     if (options.start > doc.length) {
-      throw new MongoDriverError(
-        'Stream start (' +
-          options.start +
-          ') must not be ' +
-          'more than the length of the file (' +
-          doc.length +
-          ')'
+      throw new MongoInvalidArgumentError(
+        `Stream start (${options.start}) must not be more than the length of the file (${doc.length})`
       );
     }
     if (options.start < 0) {
-      throw new MongoDriverError('Stream start (' + options.start + ') must not be ' + 'negative');
+      throw new MongoInvalidArgumentError(`Stream start (${options.start}) must not be negative`);
     }
     if (options.end != null && options.end < options.start) {
-      throw new MongoDriverError(
-        'Stream start (' +
-          options.start +
-          ') must not be ' +
-          'greater than stream end (' +
-          options.end +
-          ')'
+      throw new MongoInvalidArgumentError(
+        `Stream start (${options.start}) must not be greater than stream end (${options.end})`
       );
     }
 
@@ -419,7 +423,7 @@ function handleStartOption(
 
     return options.start - stream.s.bytesRead;
   }
-  throw new MongoDriverError('No start option defined');
+  throw new MongoInvalidArgumentError('Start option must be defined');
 }
 
 function handleEndOption(
@@ -430,17 +434,12 @@ function handleEndOption(
 ) {
   if (options && options.end != null) {
     if (options.end > doc.length) {
-      throw new MongoDriverError(
-        'Stream end (' +
-          options.end +
-          ') must not be ' +
-          'more than the length of the file (' +
-          doc.length +
-          ')'
+      throw new MongoInvalidArgumentError(
+        `Stream end (${options.end}) must not be more than the length of the file (${doc.length})`
       );
     }
     if (options.start == null || options.start < 0) {
-      throw new MongoDriverError('Stream end (' + options.end + ') must not be ' + 'negative');
+      throw new MongoInvalidArgumentError(`Stream end (${options.end}) must not be negative`);
     }
 
     const start = options.start != null ? Math.floor(options.start / doc.chunkSize) : 0;
@@ -451,9 +450,5 @@ function handleEndOption(
 
     return Math.ceil(options.end / doc.chunkSize) * doc.chunkSize - options.end;
   }
-  throw new MongoDriverError('No end option defined');
-}
-
-function __handleError(stream: GridFSBucketReadStream, error?: AnyError): void {
-  stream.emit(GridFSBucketReadStream.ERROR, error);
+  throw new MongoInvalidArgumentError('End option must be defined');
 }

package/src/gridfs/index.ts

@@ -1,4 +1,4 @@
-import { MongoDriverError } from '../error';
+import { MongoRuntimeError } from '../error';
 import {
   GridFSBucketReadStream,
   GridFSBucketReadStreamOptions,
@@ -227,8 +227,9 @@ function _delete(bucket: GridFSBucket, id: ObjectId, callback: Callback<void>):
 
       // Delete orphaned chunks before returning FileNotFound
       if (!res?.deletedCount) {
-        const errmsg = 'FileNotFound: no file with id ' + id + ' found';
-        return callback(new MongoDriverError(errmsg));
+        // TODO(NODE-3483): Replace with more appropriate error
+        // Consider creating new error MongoGridFSFileNotFoundError
+        return callback(new MongoRuntimeError(`File not found for id ${id}`));
       }
 
       return callback();
@@ -250,7 +251,7 @@ function _rename(
     }
 
     if (!res?.matchedCount) {
-      return callback(new MongoDriverError(`File with id ${id} not found`));
+      return callback(new MongoRuntimeError(`File with id ${id} not found`));
     }
 
     return callback();

package/src/gridfs/upload.ts

@@ -1,14 +1,13 @@
 import { Writable } from 'stream';
-import { MongoError, AnyError, MONGODB_ERROR_CODES, MongoDriverError } from '../error';
-import { WriteConcern } from './../write_concern';
-import { PromiseProvider } from '../promise_provider';
-import { ObjectId } from '../bson';
-import type { Callback } from '../utils';
 import type { Document } from '../bson';
-import type { GridFSBucket } from './index';
-import type { GridFSFile } from './download';
-import type { WriteConcernOptions } from '../write_concern';
+import { ObjectId } from '../bson';
 import type { Collection } from '../collection';
+import { AnyError, MONGODB_ERROR_CODES, MongoError, MongoAPIError } from '../error';
+import { Callback, maybePromise } from '../utils';
+import type { WriteConcernOptions } from '../write_concern';
+import { WriteConcern } from './../write_concern';
+import type { GridFSFile } from './download';
+import type { GridFSBucket } from './index';
 
 /** @public */
 export interface GridFSChunk {
@@ -38,7 +37,7 @@ export interface GridFSBucketWriteStreamOptions extends WriteConcernOptions {
  * Do not instantiate this class directly. Use `openUploadStream()` instead.
  * @public
  */
-export class GridFSBucketWriteStream extends Writable {
+export class GridFSBucketWriteStream extends Writable implements NodeJS.WritableStream {
   bucket: GridFSBucket;
   chunks: Collection<GridFSChunk>;
   filename: string;
@@ -119,12 +118,16 @@ export class GridFSBucketWriteStream extends 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): boolean;
-  write(chunk: Buffer, callback: Callback<void>): boolean;
-  write(chunk: Buffer, encoding: BufferEncoding | undefined): boolean;
-  write(chunk: Buffer, encoding: BufferEncoding | undefined, callback: Callback<void>): boolean;
+  write(chunk: Buffer | string): boolean;
+  write(chunk: Buffer | string, callback: Callback<void>): boolean;
+  write(chunk: Buffer | string, encoding: BufferEncoding | undefined): boolean;
   write(
-    chunk: Buffer,
+    chunk: Buffer | string,
+    encoding: BufferEncoding | undefined,
+    callback: Callback<void>
+  ): boolean;
+  write(
+    chunk: Buffer | string,
     encodingOrCallback?: Callback<void> | BufferEncoding,
     callback?: Callback<void>
   ): boolean {
@@ -133,6 +136,7 @@ export class GridFSBucketWriteStream extends Writable {
     return waitForIndexes(this, () => doWrite(this, chunk, encoding, callback));
   }
 
+  // TODO(NODE-3405): Refactor this with maybePromise and MongoStreamClosedError
   /**
    * Places this write stream into an aborted state (all future writes fail)
    * and deletes all chunks that have already been written.
@@ -142,25 +146,19 @@ export class GridFSBucketWriteStream extends Writable {
   abort(): Promise<void>;
   abort(callback: Callback<void>): void;
   abort(callback?: Callback<void>): Promise<void> | void {
-    const Promise = PromiseProvider.get();
-    let error: MongoDriverError;
-    if (this.state.streamEnd) {
-      error = new MongoDriverError('Cannot abort a stream that has already completed');
-      if (typeof callback === 'function') {
-        return callback(error);
+    return maybePromise(callback, callback => {
+      if (this.state.streamEnd) {
+        // TODO(NODE-3485): Replace with MongoGridFSStreamClosed
+        return callback(new MongoAPIError('Cannot abort a stream that has already completed'));
       }
-      return Promise.reject(error);
-    }
-    if (this.state.aborted) {
-      error = new MongoDriverError('Cannot call abort() on a stream twice');
-      if (typeof callback === 'function') {
-        return callback(error);
+
+      if (this.state.aborted) {
+        // TODO(NODE-3485): Replace with MongoGridFSStreamClosed
+        return callback(new MongoAPIError('Cannot call abort() on a stream twice'));
       }
-      return Promise.reject(error);
-    }
-    this.state.aborted = true;
-    this.chunks.deleteMany({ files_id: this.id }, error => {
-      if (typeof callback === 'function') callback(error);
+
+      this.state.aborted = true;
+      this.chunks.deleteMany({ files_id: this.id }, error => callback(error));
     });
   }
 
@@ -423,7 +421,7 @@ function createFilesDoc(
 
 function doWrite(
   stream: GridFSBucketWriteStream,
-  chunk: Buffer,
+  chunk: Buffer | string,
   encoding?: BufferEncoding,
   callback?: Callback<void>
 ): boolean {
@@ -556,7 +554,8 @@ function writeRemnant(stream: GridFSBucketWriteStream, callback?: Callback): boo
 function checkAborted(stream: GridFSBucketWriteStream, callback?: Callback<void>): boolean {
   if (stream.state.aborted) {
     if (typeof callback === 'function') {
-      callback(new MongoDriverError('this stream has been aborted'));
+      // TODO(NODE-3485): Replace with MongoGridFSStreamClosedError
+      callback(new MongoAPIError('Stream has been aborted'));
     }
     return true;
   }

package/src/index.ts

@@ -29,16 +29,42 @@ export {
   Map
 } from './bson';
 
+import { ObjectId } from 'bson';
+/**
+ * @public
+ * @deprecated Please use `ObjectId`
+ */
+export const ObjectID = ObjectId;
+
 export {
   MongoError,
   MongoServerError,
   MongoDriverError,
+  MongoAPIError,
+  MongoCompatibilityError,
+  MongoInvalidArgumentError,
+  MongoMissingCredentialsError,
+  MongoMissingDependencyError,
   MongoNetworkError,
   MongoNetworkTimeoutError,
   MongoSystemError,
   MongoServerSelectionError,
   MongoParseError,
-  MongoWriteConcernError
+  MongoWriteConcernError,
+  MongoRuntimeError,
+  MongoChangeStreamError,
+  MongoGridFSStreamError,
+  MongoGridFSChunkError,
+  MongoDecompressionError,
+  MongoBatchReExecutionError,
+  MongoCursorExhaustedError,
+  MongoCursorInUseError,
+  MongoNotConnectedError,
+  MongoExpiredSessionError,
+  MongoTransactionError,
+  MongoKerberosError,
+  MongoServerClosedError,
+  MongoTopologyClosedError
 } from './error';
 export { MongoBulkWriteError, BulkWriteOptions, AnyBulkWriteOperation } from './bulk/common';
 export {
@@ -141,7 +167,11 @@ export type {
   OperationTime,
   ResumeOptions
 } from './change_stream';
-export type { MongoCredentials, MongoCredentialsOptions } from './cmap/auth/mongo_credentials';
+export type {
+  MongoCredentials,
+  AuthMechanismProperties,
+  MongoCredentialsOptions
+} from './cmap/auth/mongo_credentials';
 export type {
   WriteProtocolMessageType,
   Query,
@@ -161,6 +191,7 @@ export type {
   GetMoreOptions,
   ConnectionEvents
 } from './cmap/connection';
+export type { ConnectionPoolMetrics } from './cmap/metrics';
 export type {
   CloseOptions,
   ConnectionPoolOptions,
@@ -187,7 +218,7 @@ export type {
 } from './cursor/abstract_cursor';
 export type { DbPrivate, DbOptions } from './db';
 export type { AutoEncryptionOptions, AutoEncrypter } from './deps';
-export type { AnyError, ErrorDescription, MongoNetworkTimeoutErrorOptions } from './error';
+export type { AnyError, ErrorDescription, MongoNetworkErrorOptions } from './error';
 export type { Explain, ExplainOptions, ExplainVerbosityLike } from './explain';
 export type {
   GridFSBucketReadStream,
@@ -334,6 +365,7 @@ export type {
   ClientSession,
   ClientSessionEvents,
   ClientSessionOptions,
+  EndSessionOptions,
   ServerSessionPool,
   ServerSession,
   ServerSessionId,
@@ -353,7 +385,13 @@ export type {
 export type { W, WriteConcernOptions, WriteConcernSettings } from './write_concern';
 export type { ExecutionResult } from './operations/execute_operation';
 export type { InternalAbstractCursorOptions } from './cursor/abstract_cursor';
-export type { BulkOperationBase, BulkOperationPrivate, FindOperators, Batch } from './bulk/common';
+export type {
+  BulkOperationBase,
+  BulkOperationPrivate,
+  FindOperators,
+  Batch,
+  WriteConcernErrorData
+} from './bulk/common';
 export type { OrderedBulkOperation } from './bulk/ordered';
 export type { UnorderedBulkOperation } from './bulk/unordered';
 export type { Encrypter, EncrypterOptions } from './encrypter';

package/src/logger.ts

@@ -1,5 +1,6 @@
 import { format } from 'util';
-import { MongoDriverError } from './error';
+import { enumToString } from './utils';
+import { MongoInvalidArgumentError } from './error';
 
 // Filters for classes
 const classFilters: any = {};
@@ -222,7 +223,7 @@ export class Logger {
    */
   static setCurrentLogger(logger: LoggerFunction): void {
     if (typeof logger !== 'function') {
-      throw new MongoDriverError('current logger must be a function');
+      throw new MongoInvalidArgumentError('Current logger must be a function');
     }
 
     currentLogger = logger;
@@ -253,7 +254,9 @@ export class Logger {
       newLevel !== LoggerLevel.DEBUG &&
       newLevel !== LoggerLevel.WARN
     ) {
-      throw new MongoDriverError(`${newLevel} is an illegal logging level`);
+      throw new MongoInvalidArgumentError(
+        `Argument "newLevel" should be one of ${enumToString(LoggerLevel)}`
+      );
     }
 
     level = newLevel;

package/src/mongo_client.ts

@@ -1,7 +1,12 @@
 import { Db, DbOptions } from './db';
 import { ChangeStream, ChangeStreamOptions } from './change_stream';
 import type { ReadPreference, ReadPreferenceMode } from './read_preference';
-import { AnyError, MongoDriverError } from './error';
+import {
+  AnyError,
+  MongoRuntimeError,
+  MongoInvalidArgumentError,
+  MongoNotConnectedError
+} from './error';
 import type { W, WriteConcern } from './write_concern';
 import {
   maybePromise,
@@ -22,7 +27,7 @@ import type { AuthMechanism } from './cmap/auth/defaultAuthProviders';
 import type { Topology, TopologyEvents } from './sdam/topology';
 import type { ClientSession, ClientSessionOptions } from './sessions';
 import type { TagSet } from './sdam/server_description';
-import type { MongoCredentials } from './cmap/auth/mongo_credentials';
+import type { AuthMechanismProperties, MongoCredentials } from './cmap/auth/mongo_credentials';
 import { parseOptions } from './connection_string';
 import type { CompressorName } from './cmap/wire_protocol/compression';
 import type { TLSSocketOptions, ConnectionOptions as TLSConnectionOptions } from 'tls';
@@ -107,7 +112,7 @@ export interface MongoClientOptions extends BSONSerializeOptions, SupportedNodeC
   ssl?: boolean;
   /** Specifies the location of a local TLS Certificate */
   tlsCertificateFile?: string;
-  /** Specifies the location of a local .pem file that contains either the client’s TLS/SSL certificate or the client’s TLS/SSL certificate and key. */
+  /** Specifies the location of a local .pem file that contains either the client's TLS/SSL certificate and key or only the client's TLS/SSL key when tlsCertificateFile is used to provide the certificate. */
   tlsCertificateKeyFile?: string;
   /** Specifies the password to de-crypt the tlsCertificateKeyFile. */
   tlsCertificateKeyFilePassword?: string;
@@ -123,8 +128,8 @@ export interface MongoClientOptions extends BSONSerializeOptions, SupportedNodeC
   connectTimeoutMS?: number;
   /** The time in milliseconds to attempt a send or receive on a socket before the attempt times out. */
   socketTimeoutMS?: number;
-  /** Comma-delimited string of compressors to enable network compression for communication between this client and a mongod/mongos instance. */
-  compressors?: CompressorName[];
+  /** An array or comma-delimited string of compressors to enable network compression for communication between this client and a mongod/mongos instance. */
+  compressors?: CompressorName[] | string;
   /** An integer that specifies the compression level if using zlib for network compression. */
   zlibCompressionLevel?: 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | undefined;
   /** The maximum number of connections in the connection pool. */
@@ -152,12 +157,7 @@ export interface MongoClientOptions extends BSONSerializeOptions, SupportedNodeC
   /** Specify the authentication mechanism that MongoDB will use to authenticate the connection. */
   authMechanism?: AuthMechanism;
   /** Specify properties for the specified authMechanism as a comma-separated list of colon-separated key-value pairs. */
-  authMechanismProperties?: {
-    SERVICE_NAME?: string;
-    CANONICALIZE_HOST_NAME?: boolean;
-    SERVICE_REALM?: string;
-    [key: string]: any;
-  };
+  authMechanismProperties?: AuthMechanismProperties;
   /** The size (in milliseconds) of the latency window for selecting among multiple suitable MongoDB instances. */
   localThresholdMS?: number;
   /** Specifies how long (in milliseconds) to block for server selection before throwing an exception.  */
@@ -174,6 +174,8 @@ export interface MongoClientOptions extends BSONSerializeOptions, SupportedNodeC
   retryWrites?: boolean;
   /** Allow a driver to force a Single topology type with a connection string containing one host */
   directConnection?: boolean;
+  /** Instruct the driver it is connecting to a load balancer fronting a mongos like service */
+  loadBalanced?: boolean;
 
   /** The write concern w value */
   w?: W;
@@ -403,7 +405,7 @@ export class MongoClient extends TypedEventEmitter<MongoClientEvents> {
   connect(callback: Callback<MongoClient>): void;
   connect(callback?: Callback<MongoClient>): Promise<MongoClient> | void {
     if (callback && typeof callback !== 'function') {
-      throw new MongoDriverError('`connect` only accepts a callback');
+      throw new MongoInvalidArgumentError('Method `connect` only accepts a callback');
     }
 
     return maybePromise(callback, cb => {
@@ -473,13 +475,6 @@ export class MongoClient extends TypedEventEmitter<MongoClientEvents> {
     // Copy the options and add out internal override of the not shared flag
     const finalOptions = Object.assign({}, this[kOptions], options);
 
-    // If no topology throw an error message
-    if (!this.topology) {
-      throw new MongoDriverError(
-        'MongoClient must be connected before calling MongoClient.prototype.db'
-      );
-    }
-
     // Return the db object
     const db = new Db(this, dbName, finalOptions);
 
@@ -528,7 +523,7 @@ export class MongoClient extends TypedEventEmitter<MongoClientEvents> {
   startSession(options?: ClientSessionOptions): ClientSession {
     options = Object.assign({ explicit: true }, options);
     if (!this.topology) {
-      throw new MongoDriverError('Must connect to a server before calling this method');
+      throw new MongoNotConnectedError('MongoClient must be connected to start a session');
     }
 
     return this.topology.startSession(options, this.s.options);
@@ -556,7 +551,7 @@ export class MongoClient extends TypedEventEmitter<MongoClientEvents> {
     }
 
     if (callback == null) {
-      throw new MongoDriverError('Missing required callback parameter');
+      throw new MongoInvalidArgumentError('Missing required callback parameter');
     }
 
     const session = this.startSession(options);
@@ -565,7 +560,8 @@ export class MongoClient extends TypedEventEmitter<MongoClientEvents> {
     let cleanupHandler: CleanUpHandlerFunction = ((err, result, opts) => {
       // prevent multiple calls to cleanupHandler
       cleanupHandler = () => {
-        throw new MongoDriverError('cleanupHandler was called too many times');
+        // TODO(NODE-3483)
+        throw new MongoRuntimeError('cleanupHandler was called too many times');
       };
 
       opts = Object.assign({ throw: true }, opts);
@@ -624,7 +620,6 @@ export interface MongoOptions
       Pick<
         MongoClientOptions,
         | 'autoEncryption'
-        | 'compressors'
         | 'connectTimeoutMS'
         | 'directConnection'
         | 'driverInfo'
@@ -661,7 +656,9 @@ export interface MongoOptions
   credentials?: MongoCredentials;
   readPreference: ReadPreference;
   readConcern: ReadConcern;
+  loadBalanced: boolean;
   serverApi: ServerApi;
+  compressors: CompressorName[];
   writeConcern: WriteConcern;
   dbName: string;
   metadata: ClientMetadata;