mongodb 4.0.0 → 4.1.2

package/src/operations/find_and_modify.ts

@@ -1,6 +1,6 @@
 import { ReadPreference } from '../read_preference';
 import { maxWireVersion, decorateWithCollation, hasAtomicOperators, Callback } from '../utils';
-import { MongoDriverError } from '../error';
+import { MongoInvalidArgumentError, MongoCompatibilityError } from '../error';
 import { CommandOperation, CommandOperationOptions } from './command';
 import { defineAspects, Aspect } from './operation';
 import type { Document } from '../bson';
@@ -172,7 +172,7 @@ class FindAndModifyOperation extends CommandOperation<Document> {
       const unacknowledgedWrite = this.writeConcern?.w === 0;
       if (unacknowledgedWrite || maxWireVersion(server) < 8) {
         callback(
-          new MongoDriverError(
+          new MongoCompatibilityError(
             'The current topology does not support a hint on findAndModify commands'
           )
         );
@@ -185,7 +185,9 @@ class FindAndModifyOperation extends CommandOperation<Document> {
 
     if (this.explain && maxWireVersion(server) < 4) {
       callback(
-        new MongoDriverError(`server ${server.name} does not support explain on findAndModify`)
+        new MongoCompatibilityError(
+          `Server ${server.name} does not support explain on findAndModify`
+        )
       );
       return;
     }
@@ -203,7 +205,7 @@ export class FindOneAndDeleteOperation extends FindAndModifyOperation {
   constructor(collection: Collection, filter: Document, options: FindOneAndDeleteOptions) {
     // Basic validation
     if (filter == null || typeof filter !== 'object') {
-      throw new MongoDriverError('Filter parameter must be an object');
+      throw new MongoInvalidArgumentError('Argument "filter" must be an object');
     }
 
     super(collection, filter, options);
@@ -220,15 +222,15 @@ export class FindOneAndReplaceOperation extends FindAndModifyOperation {
     options: FindOneAndReplaceOptions
   ) {
     if (filter == null || typeof filter !== 'object') {
-      throw new MongoDriverError('Filter parameter must be an object');
+      throw new MongoInvalidArgumentError('Argument "filter" must be an object');
     }
 
     if (replacement == null || typeof replacement !== 'object') {
-      throw new MongoDriverError('Replacement parameter must be an object');
+      throw new MongoInvalidArgumentError('Argument "replacement" must be an object');
     }
 
     if (hasAtomicOperators(replacement)) {
-      throw new MongoDriverError('Replacement document must not contain atomic operators');
+      throw new MongoInvalidArgumentError('Replacement document must not contain atomic operators');
     }
 
     super(collection, filter, options);
@@ -246,15 +248,15 @@ export class FindOneAndUpdateOperation extends FindAndModifyOperation {
     options: FindOneAndUpdateOptions
   ) {
     if (filter == null || typeof filter !== 'object') {
-      throw new MongoDriverError('Filter parameter must be an object');
+      throw new MongoInvalidArgumentError('Argument "filter" must be an object');
     }
 
     if (update == null || typeof update !== 'object') {
-      throw new MongoDriverError('Update parameter must be an object');
+      throw new MongoInvalidArgumentError('Argument "update" must be an object');
     }
 
     if (!hasAtomicOperators(update)) {
-      throw new MongoDriverError('Update document requires atomic operators');
+      throw new MongoInvalidArgumentError('Update document requires atomic operators');
     }
 
     super(collection, filter, options);

package/src/operations/indexes.ts

@@ -1,6 +1,6 @@
 import { indexInformation, IndexInformationOptions } from './common_functions';
 import { AbstractOperation, Aspect, defineAspects } from './operation';
-import { MONGODB_ERROR_CODES, MongoDriverError, MongoServerError } from '../error';
+import { MONGODB_ERROR_CODES, MongoServerError, MongoCompatibilityError } from '../error';
 import {
   maxWireVersion,
   parseIndexOptions,
@@ -35,6 +35,7 @@ const VALID_INDEX_OPTIONS = new Set([
   'expireAfterSeconds',
   'storageEngine',
   'collation',
+  'version',
 
   // text indexes
   'weights',
@@ -70,7 +71,28 @@ export type IndexSpecification = OneOrMore<
 >;
 
 /** @public */
-export interface IndexDescription {
+export interface IndexDescription
+  extends Pick<
+    CreateIndexesOptions,
+    | 'background'
+    | 'unique'
+    | 'partialFilterExpression'
+    | 'sparse'
+    | 'hidden'
+    | 'expireAfterSeconds'
+    | 'storageEngine'
+    | 'version'
+    | 'weights'
+    | 'default_language'
+    | 'language_override'
+    | 'textIndexVersion'
+    | '2dsphereIndexVersion'
+    | 'bits'
+    | 'min'
+    | 'max'
+    | 'bucketSize'
+    | 'wildcardProjection'
+  > {
   collation?: CollationOptions;
   name?: string;
   key: Document;
@@ -90,9 +112,12 @@ export interface CreateIndexesOptions extends CommandOperationOptions {
   sparse?: boolean;
   /** Allows you to expire data on indexes applied to a data (MongoDB 2.2 or higher) */
   expireAfterSeconds?: number;
+  /** Allows users to configure the storage engine on a per-index basis when creating an index. (MongoDB 3.0 or higher) */
   storageEngine?: Document;
   /** (MongoDB 4.4. or higher) Specifies how many data-bearing members of a replica set, including the primary, must complete the index builds successfully before the primary marks the indexes as ready. This option accepts the same values for the "w" field in a write concern plus "votingMembers", which indicates all voting data-bearing nodes. */
   commitQuorum?: number | string;
+  /** Specifies the index version number, either 0 or 1. */
+  version?: number;
   // text indexes
   weights?: Document;
   default_language?: string;
@@ -110,6 +135,8 @@ export interface CreateIndexesOptions extends CommandOperationOptions {
   bucketSize?: number;
   // wildcard indexes
   wildcardProjection?: Document;
+  /** Specifies that the index should exist on the target collection but should not be used by the query planner when executing operations. (MongoDB 4.4 or higher) */
+  hidden?: boolean;
 }
 
 function makeIndexSpec(indexSpec: IndexSpecification, options: any): IndexDescription {
@@ -132,7 +159,7 @@ function makeIndexSpec(indexSpec: IndexSpecification, options: any): IndexDescri
 }
 
 /** @internal */
-export class IndexesOperation extends AbstractOperation<Document> {
+export class IndexesOperation extends AbstractOperation<Document[]> {
   options: IndexInformationOptions;
   collection: Collection;
 
@@ -142,7 +169,7 @@ export class IndexesOperation extends AbstractOperation<Document> {
     this.collection = collection;
   }
 
-  execute(server: Server, session: ClientSession, callback: Callback<Document>): void {
+  execute(server: Server, session: ClientSession, callback: Callback<Document[]>): void {
     const coll = this.collection;
     const options = this.options;
 
@@ -188,7 +215,7 @@ export class CreateIndexesOperation<
       // Did the user pass in a collation, check if our write server supports it
       if (indexes[i].collation && serverWireVersion < 5) {
         callback(
-          new MongoDriverError(
+          new MongoCompatibilityError(
             `Server ${server.name}, which reports wire version ${serverWireVersion}, ` +
               'does not support collation'
           )
@@ -213,8 +240,8 @@ export class CreateIndexesOperation<
     if (options.commitQuorum != null) {
       if (serverWireVersion < 9) {
         callback(
-          new MongoDriverError(
-            '`commitQuorum` option for `createIndexes` not supported on servers < 4.4'
+          new MongoCompatibilityError(
+            'Option `commitQuorum` for `createIndexes` not supported on servers < 4.4'
           )
         );
         return;
@@ -486,7 +513,11 @@ export class IndexInformationOperation extends AbstractOperation<Document> {
   }
 }
 
-defineAspects(ListIndexesOperation, [Aspect.READ_OPERATION, Aspect.RETRYABLE]);
+defineAspects(ListIndexesOperation, [
+  Aspect.READ_OPERATION,
+  Aspect.RETRYABLE,
+  Aspect.CURSOR_CREATING
+]);
 defineAspects(CreateIndexesOperation, [Aspect.WRITE_OPERATION]);
 defineAspects(CreateIndexOperation, [Aspect.WRITE_OPERATION]);
 defineAspects(EnsureIndexOperation, [Aspect.WRITE_OPERATION]);

package/src/operations/insert.ts

@@ -1,4 +1,4 @@
-import { MongoDriverError, MongoServerError } from '../error';
+import { MongoServerError, MongoInvalidArgumentError } from '../error';
 import { defineAspects, Aspect, AbstractOperation } from './operation';
 import { CommandOperation, CommandOperationOptions } from './command';
 import { prepareDocs } from './common_functions';
@@ -37,7 +37,7 @@ export class InsertOperation extends CommandOperation<Document> {
       command.bypassDocumentValidation = options.bypassDocumentValidation;
     }
 
-    if (typeof options.comment !== 'undefined') {
+    if (options.comment != null) {
       command.comment = options.comment;
     }
 
@@ -70,7 +70,10 @@ export class InsertOneOperation extends InsertOperation {
     super.execute(server, session, (err, res) => {
       if (err || res == null) return callback(err);
       if (res.code) return callback(new MongoServerError(res));
-      if (res.writeErrors) return callback(new MongoServerError(res.writeErrors[0]));
+      if (res.writeErrors) {
+        // This should be a WriteError but we can't change it now because of error hierarchy
+        return callback(new MongoServerError(res.writeErrors[0]));
+      }
 
       callback(undefined, {
         acknowledged: this.writeConcern?.w !== 0 ?? true,
@@ -100,7 +103,7 @@ export class InsertManyOperation extends AbstractOperation<InsertManyResult> {
     super(options);
 
     if (!Array.isArray(docs)) {
-      throw new MongoDriverError('docs parameter must be an array of documents');
+      throw new MongoInvalidArgumentError('Argument "docs" must be an array of documents');
     }
 
     this.options = options;

package/src/operations/is_capped.ts

@@ -3,7 +3,7 @@ import type { Collection } from '../collection';
 import { OperationOptions, AbstractOperation } from './operation';
 import type { Server } from '../sdam/server';
 import type { ClientSession } from '../sessions';
-import { MongoDriverError } from '../error';
+import { MongoAPIError } from '../error';
 
 /** @internal */
 export class IsCappedOperation extends AbstractOperation<boolean> {
@@ -27,7 +27,8 @@ export class IsCappedOperation extends AbstractOperation<boolean> {
       .toArray((err, collections) => {
         if (err || !collections) return callback(err);
         if (collections.length === 0) {
-          return callback(new MongoDriverError(`collection ${coll.namespace} not found`));
+          // TODO(NODE-3485)
+          return callback(new MongoAPIError(`collection ${coll.namespace} not found`));
         }
 
         const collOptions = collections[0].options;

package/src/operations/list_collections.ts

@@ -46,10 +46,7 @@ export class ListCollectionsOperation extends CommandOperation<string[]> {
       const databaseName = this.db.s.namespace.db;
 
       // If we have legacy mode and have not provided a full db name filter it
-      if (
-        typeof filter.name === 'string' &&
-        !new RegExp('^' + databaseName + '\\.').test(filter.name)
-      ) {
+      if (typeof filter.name === 'string' && !new RegExp(`^${databaseName}\\.`).test(filter.name)) {
         filter = Object.assign({}, filter);
         filter.name = this.db.s.namespace.withCollection(filter.name).toString();
       }
@@ -118,7 +115,9 @@ export interface CollectionInfo extends Document {
 
 /** @public */
 export class ListCollectionsCursor<
-  T extends Pick<CollectionInfo, 'name' | 'type'> | CollectionInfo = CollectionInfo
+  T extends Pick<CollectionInfo, 'name' | 'type'> | CollectionInfo =
+    | Pick<CollectionInfo, 'name' | 'type'>
+    | CollectionInfo
 > extends AbstractCursor<T> {
   parent: Db;
   filter: Document;
@@ -155,4 +154,8 @@ export class ListCollectionsCursor<
   }
 }
 
-defineAspects(ListCollectionsOperation, [Aspect.READ_OPERATION, Aspect.RETRYABLE]);
+defineAspects(ListCollectionsOperation, [
+  Aspect.READ_OPERATION,
+  Aspect.RETRYABLE,
+  Aspect.CURSOR_CREATING
+]);

package/src/operations/map_reduce.ts

@@ -12,7 +12,7 @@ import { CommandOperation, CommandOperationOptions } from './command';
 import type { Server } from '../sdam/server';
 import type { Collection } from '../collection';
 import type { Sort } from '../sort';
-import { MongoDriverError, MongoServerError } from '../error';
+import { MongoServerError, MongoCompatibilityError } from '../error';
 import type { ObjectId } from '../bson';
 import { Aspect, defineAspects } from './operation';
 import type { ClientSession } from '../sessions';
@@ -165,7 +165,9 @@ export class MapReduceOperation extends CommandOperation<Document | Document[]>
     }
 
     if (this.explain && maxWireVersion(server) < 9) {
-      callback(new MongoDriverError(`server ${server.name} does not support explain on mapReduce`));
+      callback(
+        new MongoCompatibilityError(`Server ${server.name} does not support explain on mapReduce`)
+      );
       return;
     }
 

package/src/operations/operation.ts

@@ -9,7 +9,8 @@ export const Aspect = {
   WRITE_OPERATION: Symbol('WRITE_OPERATION'),
   RETRYABLE: Symbol('RETRYABLE'),
   EXPLAINABLE: Symbol('EXPLAINABLE'),
-  SKIP_COLLATION: Symbol('SKIP_COLLATION')
+  SKIP_COLLATION: Symbol('SKIP_COLLATION'),
+  CURSOR_CREATING: Symbol('CURSOR_CREATING')
 } as const;
 
 /** @public */
@@ -27,6 +28,9 @@ export interface OperationOptions extends BSONSerializeOptions {
 
   /** The preferred read preference (ReadPreference.primary, ReadPreference.primary_preferred, ReadPreference.secondary, ReadPreference.secondary_preferred, ReadPreference.nearest). */
   readPreference?: ReadPreferenceLike;
+
+  /** @internal Hints to `executeOperation` that this operation should not unpin on an ended transaction */
+  bypassPinningCheck?: boolean;
 }
 
 /** @internal */
@@ -44,7 +48,7 @@ export abstract class AbstractOperation<TResult = any> {
   cmd!: Document;
   readPreference: ReadPreference;
   server!: Server;
-  fullResponse?: boolean;
+  bypassPinningCheck: boolean;
 
   // BSON serialization options
   bsonOptions?: BSONSerializeOptions;
@@ -67,6 +71,7 @@ export abstract class AbstractOperation<TResult = any> {
     }
 
     this.options = options;
+    this.bypassPinningCheck = !!options.bypassPinningCheck;
   }
 
   abstract execute(server: Server, session: ClientSession, callback: Callback<TResult>): void;

package/src/operations/options_operation.ts

@@ -1,5 +1,5 @@
 import { AbstractOperation, OperationOptions } from './operation';
-import { MongoDriverError } from '../error';
+import { MongoAPIError } from '../error';
 import type { Callback } from '../utils';
 import type { Document } from '../bson';
 import type { Collection } from '../collection';
@@ -28,7 +28,8 @@ export class OptionsOperation extends AbstractOperation<Document> {
       .toArray((err, collections) => {
         if (err || !collections) return callback(err);
         if (collections.length === 0) {
-          return callback(new MongoDriverError(`collection ${coll.namespace} not found`));
+          // TODO(NODE-3485)
+          return callback(new MongoAPIError(`collection ${coll.namespace} not found`));
         }
 
         callback(err, collections[0].options);

package/src/operations/profiling_level.ts

@@ -3,7 +3,7 @@ import type { Callback } from '../utils';
 import type { Server } from '../sdam/server';
 import type { Db } from '../db';
 import type { ClientSession } from '../sessions';
-import { MongoDriverError } from '../error';
+import { MongoRuntimeError } from '../error';
 
 /** @public */
 export type ProfilingLevelOptions = CommandOperationOptions;
@@ -24,9 +24,11 @@ export class ProfilingLevelOperation extends CommandOperation<string> {
         if (was === 0) return callback(undefined, 'off');
         if (was === 1) return callback(undefined, 'slow_only');
         if (was === 2) return callback(undefined, 'all');
-        return callback(new MongoDriverError('Error: illegal profiling level value ' + was));
+        // TODO(NODE-3483)
+        return callback(new MongoRuntimeError(`Illegal profiling level value ${was}`));
       } else {
-        err != null ? callback(err) : callback(new MongoDriverError('Error with profile command'));
+        // TODO(NODE-3483): Consider MongoUnexpectedServerResponseError
+        err != null ? callback(err) : callback(new MongoRuntimeError('Error with profile command'));
       }
     });
   }

package/src/operations/set_profiling_level.ts

@@ -1,9 +1,10 @@
 import { CommandOperation, CommandOperationOptions } from './command';
 import type { Callback } from '../utils';
+import { enumToString } from '../utils';
 import type { Server } from '../sdam/server';
 import type { Db } from '../db';
 import type { ClientSession } from '../sessions';
-import { MongoDriverError } from '../error';
+import { MongoRuntimeError, MongoInvalidArgumentError } from '../error';
 const levelValues = new Set(['off', 'slow_only', 'all']);
 
 /** @public */
@@ -50,14 +51,19 @@ export class SetProfilingLevelOperation extends CommandOperation<ProfilingLevel>
     const level = this.level;
 
     if (!levelValues.has(level)) {
-      return callback(new MongoDriverError('Error: illegal profiling level value ' + level));
+      return callback(
+        new MongoInvalidArgumentError(
+          `Profiling level must be one of "${enumToString(ProfilingLevel)}"`
+        )
+      );
     }
 
+    // TODO(NODE-3483): Determine error to put here
     super.executeCommand(server, session, { profile: this.profile }, (err, doc) => {
       if (err == null && doc.ok === 1) return callback(undefined, level);
       return err != null
         ? callback(err)
-        : callback(new MongoDriverError('Error with profile command'));
+        : callback(new MongoRuntimeError('Error with profile command'));
     });
   }
 }

package/src/operations/update.ts

@@ -11,7 +11,7 @@ import type { Server } from '../sdam/server';
 import type { Collection } from '../collection';
 import type { ObjectId, Document } from '../bson';
 import type { ClientSession } from '../sessions';
-import { MongoDriverError, MongoServerError } from '../error';
+import { MongoServerError, MongoInvalidArgumentError, MongoCompatibilityError } from '../error';
 
 /** @public */
 export interface UpdateOptions extends CommandOperationOptions {
@@ -108,25 +108,29 @@ export class UpdateOperation extends CommandOperation<Document> {
       collationNotSupported(server, options) ||
       (statementWithCollation && collationNotSupported(server, statementWithCollation))
     ) {
-      callback(new MongoDriverError(`server ${server.name} does not support collation`));
+      callback(new MongoCompatibilityError(`Server ${server.name} does not support collation`));
       return;
     }
 
     const unacknowledgedWrite = this.writeConcern && this.writeConcern.w === 0;
     if (unacknowledgedWrite || maxWireVersion(server) < 5) {
       if (this.statements.find((o: Document) => o.hint)) {
-        callback(new MongoDriverError(`servers < 3.4 do not support hint on update`));
+        callback(new MongoCompatibilityError(`Servers < 3.4 do not support hint on update`));
         return;
       }
     }
 
     if (this.explain && maxWireVersion(server) < 3) {
-      callback(new MongoDriverError(`server ${server.name} does not support explain on update`));
+      callback(
+        new MongoCompatibilityError(`Server ${server.name} does not support explain on update`)
+      );
       return;
     }
 
     if (this.statements.some(statement => !!statement.arrayFilters) && maxWireVersion(server) < 6) {
-      callback(new MongoDriverError('arrayFilters are only supported on MongoDB 3.6+'));
+      callback(
+        new MongoCompatibilityError('Option "arrayFilters" is only supported on MongoDB 3.6+')
+      );
       return;
     }
 
@@ -144,7 +148,7 @@ export class UpdateOneOperation extends UpdateOperation {
     );
 
     if (!hasAtomicOperators(update)) {
-      throw new MongoDriverError('Update document requires atomic operators');
+      throw new MongoInvalidArgumentError('Update document requires atomic operators');
     }
   }
 
@@ -155,7 +159,7 @@ export class UpdateOneOperation extends UpdateOperation {
   ): void {
     super.execute(server, session, (err, res) => {
       if (err || !res) return callback(err);
-      if (typeof this.explain !== 'undefined') return callback(undefined, res);
+      if (this.explain != null) return callback(undefined, res);
       if (res.code) return callback(new MongoServerError(res));
       if (res.writeErrors) return callback(new MongoServerError(res.writeErrors[0]));
 
@@ -181,7 +185,7 @@ export class UpdateManyOperation extends UpdateOperation {
     );
 
     if (!hasAtomicOperators(update)) {
-      throw new MongoDriverError('Update document requires atomic operators');
+      throw new MongoInvalidArgumentError('Update document requires atomic operators');
     }
   }
 
@@ -192,7 +196,7 @@ export class UpdateManyOperation extends UpdateOperation {
   ): void {
     super.execute(server, session, (err, res) => {
       if (err || !res) return callback(err);
-      if (typeof this.explain !== 'undefined') return callback(undefined, res);
+      if (this.explain != null) return callback(undefined, res);
       if (res.code) return callback(new MongoServerError(res));
       if (res.writeErrors) return callback(new MongoServerError(res.writeErrors[0]));
 
@@ -235,7 +239,7 @@ export class ReplaceOneOperation extends UpdateOperation {
     );
 
     if (hasAtomicOperators(replacement)) {
-      throw new MongoDriverError('Replacement document must not contain atomic operators');
+      throw new MongoInvalidArgumentError('Replacement document must not contain atomic operators');
     }
   }
 
@@ -246,7 +250,7 @@ export class ReplaceOneOperation extends UpdateOperation {
   ): void {
     super.execute(server, session, (err, res) => {
       if (err || !res) return callback(err);
-      if (typeof this.explain !== 'undefined') return callback(undefined, res);
+      if (this.explain != null) return callback(undefined, res);
       if (res.code) return callback(new MongoServerError(res));
       if (res.writeErrors) return callback(new MongoServerError(res.writeErrors[0]));
 
@@ -268,11 +272,11 @@ export function makeUpdateStatement(
   options: UpdateOptions & { multi?: boolean }
 ): UpdateStatement {
   if (filter == null || typeof filter !== 'object') {
-    throw new MongoDriverError('selector must be a valid JavaScript object');
+    throw new MongoInvalidArgumentError('Selector must be a valid JavaScript object');
   }
 
   if (update == null || typeof update !== 'object') {
-    throw new MongoDriverError('document must be a valid JavaScript object');
+    throw new MongoInvalidArgumentError('Document must be a valid JavaScript object');
   }
 
   const op: UpdateStatement = { q: filter, u: update };

package/src/operations/validate_collection.ts

@@ -4,7 +4,7 @@ import type { Document } from '../bson';
 import type { Server } from '../sdam/server';
 import type { Admin } from '../admin';
 import type { ClientSession } from '../sessions';
-import { MongoDriverError } from '../error';
+import { MongoRuntimeError } from '../error';
 
 /** @public */
 export interface ValidateCollectionOptions extends CommandOperationOptions {
@@ -40,13 +40,14 @@ export class ValidateCollectionOperation extends CommandOperation<Document> {
     super.executeCommand(server, session, this.command, (err, doc) => {
       if (err != null) return callback(err);
 
-      if (doc.ok === 0) return callback(new MongoDriverError('Error with validate command'));
-      if (doc.result != null && doc.result.constructor !== String)
-        return callback(new MongoDriverError('Error with validation data'));
+      // TODO(NODE-3483): Replace these with MongoUnexpectedServerResponseError
+      if (doc.ok === 0) return callback(new MongoRuntimeError('Error with validate command'));
+      if (doc.result != null && typeof doc.result !== 'string')
+        return callback(new MongoRuntimeError('Error with validation data'));
       if (doc.result != null && doc.result.match(/exception|corrupt/) != null)
-        return callback(new MongoDriverError('Error: invalid collection ' + collectionName));
+        return callback(new MongoRuntimeError(`Invalid collection ${collectionName}`));
       if (doc.valid != null && !doc.valid)
-        return callback(new MongoDriverError('Error: invalid collection ' + collectionName));
+        return callback(new MongoRuntimeError(`Invalid collection ${collectionName}`));
 
       return callback(undefined, doc);
     });

package/src/promise_provider.ts

@@ -1,4 +1,4 @@
-import { MongoDriverError } from './error';
+import { MongoInvalidArgumentError } from './error';
 
 /** @internal */
 const kPromise = Symbol('promise');
@@ -19,7 +19,7 @@ export class PromiseProvider {
   /** Validates the passed in promise library */
   static validate(lib: unknown): lib is PromiseConstructor {
     if (typeof lib !== 'function')
-      throw new MongoDriverError(`Promise must be a function, got ${lib}`);
+      throw new MongoInvalidArgumentError(`Promise must be a function, got ${lib}`);
     return !!lib;
   }
 

package/src/read_preference.ts

@@ -1,7 +1,7 @@
 import type { TagSet } from './sdam/server_description';
 import type { Document } from './bson';
 import type { ClientSession } from './sessions';
-import { MongoDriverError } from './error';
+import { MongoInvalidArgumentError } from './error';
 
 /** @public */
 export type ReadPreferenceLike = ReadPreference | ReadPreferenceMode;
@@ -84,13 +84,13 @@ export class ReadPreference {
    */
   constructor(mode: ReadPreferenceMode, tags?: TagSet[], options?: ReadPreferenceOptions) {
     if (!ReadPreference.isValid(mode)) {
-      throw new MongoDriverError(`Invalid read preference mode ${JSON.stringify(mode)}`);
+      throw new MongoInvalidArgumentError(`Invalid read preference mode ${JSON.stringify(mode)}`);
     }
-    if (options === undefined && typeof tags === 'object' && !Array.isArray(tags)) {
+    if (options == null && typeof tags === 'object' && !Array.isArray(tags)) {
       options = tags;
       tags = undefined;
     } else if (tags && !Array.isArray(tags)) {
-      throw new MongoDriverError('ReadPreference tags must be an array');
+      throw new MongoInvalidArgumentError('ReadPreference tags must be an array');
     }
 
     this.mode = mode;
@@ -102,7 +102,7 @@ export class ReadPreference {
     options = options ?? {};
     if (options.maxStalenessSeconds != null) {
       if (options.maxStalenessSeconds <= 0) {
-        throw new MongoDriverError('maxStalenessSeconds must be a positive integer');
+        throw new MongoInvalidArgumentError('maxStalenessSeconds must be a positive integer');
       }
 
       this.maxStalenessSeconds = options.maxStalenessSeconds;
@@ -114,17 +114,19 @@ export class ReadPreference {
 
     if (this.mode === ReadPreference.PRIMARY) {
       if (this.tags && Array.isArray(this.tags) && this.tags.length > 0) {
-        throw new MongoDriverError('Primary read preference cannot be combined with tags');
+        throw new MongoInvalidArgumentError('Primary read preference cannot be combined with tags');
       }
 
       if (this.maxStalenessSeconds) {
-        throw new MongoDriverError(
+        throw new MongoInvalidArgumentError(
           'Primary read preference cannot be combined with maxStalenessSeconds'
         );
       }
 
       if (this.hedge) {
-        throw new MongoDriverError('Primary read preference cannot be combined with hedge');
+        throw new MongoInvalidArgumentError(
+          'Primary read preference cannot be combined with hedge'
+        );
       }
     }
   }
@@ -193,7 +195,7 @@ export class ReadPreference {
         });
       }
     } else if (!(r instanceof ReadPreference)) {
-      throw new MongoDriverError('Invalid read preference: ' + r);
+      throw new MongoInvalidArgumentError(`Invalid read preference: ${r}`);
     }
 
     return options;