refactor(NODE-3554): Prune MongoDriverError instances (#2941)

Author: W-A-James

src/change_stream.ts

@@ -3,10 +3,9 @@ import {
   MongoError,
   AnyError,
   isResumableError,
-  MongoDriverError,
+  MongoRuntimeError,
   MongoAPIError,
-  MongoChangeStreamError,
-  MongoRuntimeError
+  MongoChangeStreamError
 } from './error';
 import { AggregateOperation, AggregateOptions } from './operations/aggregate';
 import {
@@ -639,7 +638,7 @@ function waitForTopologyConnected(
 
     if (calculateDurationInMs(start) > timeout) {
       // TODO(NODE-3497): Replace with MongoNetworkTimeoutError
-      return callback(new MongoDriverError('Timed out waiting for connection'));
+      return callback(new MongoRuntimeError('Timed out waiting for connection'));
     }
 
     waitForTopologyConnected(topology, options, callback);

src/cmap/auth/auth_provider.ts

@@ -3,7 +3,7 @@ import type { Connection, ConnectionOptions } from '../connection';
 import type { MongoCredentials } from './mongo_credentials';
 import type { HandshakeDocument } from '../connect';
 import type { ClientMetadataOptions, Callback } from '../../utils';
-import { MongoDriverError } from '../../error';
+import { MongoRuntimeError } from '../../error';
 
 export type AuthContextOptions = ConnectionOptions & ClientMetadataOptions;
 
@@ -54,7 +54,7 @@ export class AuthProvider {
    * @param callback - The callback to return the result from the authentication
    */
   auth(context: AuthContext, callback: Callback): void {
-    // TODO(NODE-3485): Replace this with MongoMethodOverrideError
-    callback(new MongoDriverError('`auth` method must be overridden by subclass'));
+    // TODO(NODE-3483): Replace this with MongoMethodOverrideError
+    callback(new MongoRuntimeError('`auth` method must be overridden by subclass'));
   }
 }

src/cmap/auth/gssapi.ts

@@ -1,6 +1,6 @@
 import { AuthProvider, AuthContext } from './auth_provider';
 import {
-  MongoDriverError,
+  MongoRuntimeError,
   MongoInvalidArgumentError,
   MongoMissingCredentialsError,
   MongoError,
@@ -106,7 +106,8 @@ function makeKerberosClient(authContext: AuthContext, callback: Callback<Kerbero
       }
 
       initializeClient(spn, initOptions, (err: string, client: KerberosClient): void => {
-        if (err) return callback(new MongoDriverError(err));
+        // TODO(NODE-3483)
+        if (err) return callback(new MongoRuntimeError(err));
         callback(undefined, client);
       });
     }

src/cmap/auth/mongo_credentials.ts

@@ -1,7 +1,7 @@
 // Resolves the default auth mechanism according to
 
 import type { Document } from '../../bson';
-import { MongoDriverError, MongoMissingCredentialsError } from '../../error';
+import { MongoAPIError, MongoMissingCredentialsError } from '../../error';
 import { AuthMechanism } from './defaultAuthProviders';
 
 // https://github.com/mongodb/specifications/blob/master/source/auth/auth.rst
@@ -131,25 +131,25 @@ export class MongoCredentials {
       this.mechanism === AuthMechanism.MONGODB_X509
     ) {
       if (this.source != null && this.source !== '$external') {
-        // TODO(NODE-3483): Replace this with a MongoAuthValidationError
-        throw new MongoDriverError(
+        // TODO(NODE-3485): Replace this with a MongoAuthValidationError
+        throw new MongoAPIError(
           `Invalid source '${this.source}' for mechanism '${this.mechanism}' specified.`
         );
       }
     }
 
     if (this.mechanism === AuthMechanism.MONGODB_PLAIN && this.source == null) {
-      // TODO(NODE-3483): Replace this with a MongoAuthValidationError
-      throw new MongoDriverError('PLAIN Authentication Mechanism needs an auth source');
+      // TODO(NODE-3485): Replace this with a MongoAuthValidationError
+      throw new MongoAPIError('PLAIN Authentication Mechanism needs an auth source');
     }
 
     if (this.mechanism === AuthMechanism.MONGODB_X509 && this.password != null) {
       if (this.password === '') {
         Reflect.set(this, 'password', undefined);
         return;
       }
-      // TODO(NODE-3483): Replace this with a MongoAuthValidationError
-      throw new MongoDriverError(`Password not allowed for mechanism MONGODB-X509`);
+      // TODO(NODE-3485): Replace this with a MongoAuthValidationError
+      throw new MongoAPIError(`Password not allowed for mechanism MONGODB-X509`);
     }
   }
 

src/cmap/auth/mongodb_aws.ts

@@ -5,7 +5,7 @@ import * as BSON from '../../bson';
 import { AuthProvider, AuthContext } from './auth_provider';
 import { MongoCredentials } from './mongo_credentials';
 import {
-  MongoDriverError,
+  MongoRuntimeError,
   MongoMissingCredentialsError,
   MongoCompatibilityError
 } from '../../error';
@@ -88,19 +88,22 @@ export class MongoDBAWS extends AuthProvider {
         const serverNonce = serverResponse.s.buffer;
         if (serverNonce.length !== 64) {
           callback(
-            new MongoDriverError(`Invalid server nonce length ${serverNonce.length}, expected 64`)
+            // TODO(NODE-3483)
+            new MongoRuntimeError(`Invalid server nonce length ${serverNonce.length}, expected 64`)
           );
 
           return;
         }
 
         if (serverNonce.compare(nonce, 0, nonce.length, 0, nonce.length) !== 0) {
-          callback(new MongoDriverError('Server nonce does not begin with client nonce'));
+          // TODO(NODE-3483)
+          callback(new MongoRuntimeError('Server nonce does not begin with client nonce'));
           return;
         }
 
         if (host.length < 1 || host.length > 255 || host.indexOf('..') !== -1) {
-          callback(new MongoDriverError(`Server returned an invalid host: "${host}"`));
+          // TODO(NODE-3483)
+          callback(new MongoRuntimeError(`Server returned an invalid host: "${host}"`));
           return;
         }
 
@@ -274,7 +277,8 @@ function request(uri: string, _options: RequestOptions | Callback, _callback?: C
         const parsed = JSON.parse(data);
         callback(undefined, parsed);
       } catch (err) {
-        callback(new MongoDriverError(`Invalid JSON response: "${data}"`));
+        // TODO(NODE-3483)
+        callback(new MongoRuntimeError(`Invalid JSON response: "${data}"`));
       }
     });
   });

src/cmap/auth/scram.ts

@@ -2,7 +2,7 @@ import * as crypto from 'crypto';
 import { Binary, Document } from '../../bson';
 import {
   AnyError,
-  MongoDriverError,
+  MongoRuntimeError,
   MongoServerError,
   MongoInvalidArgumentError,
   MongoMissingCredentialsError
@@ -169,7 +169,8 @@ function continueScramConversation(
   const iterations = parseInt(dict.i, 10);
   if (iterations && iterations < 4096) {
     callback(
-      new MongoDriverError(`Server returned an invalid iteration count ${iterations}`),
+      // TODO(NODE-3483)
+      new MongoRuntimeError(`Server returned an invalid iteration count ${iterations}`),
       false
     );
     return;
@@ -178,7 +179,8 @@ function continueScramConversation(
   const salt = dict.s;
   const rnonce = dict.r;
   if (rnonce.startsWith('nonce')) {
-    callback(new MongoDriverError(`Server returned an invalid nonce: ${rnonce}`), false);
+    // TODO(NODE-3483)
+    callback(new MongoRuntimeError(`Server returned an invalid nonce: ${rnonce}`), false);
     return;
   }
 
@@ -217,7 +219,7 @@ function continueScramConversation(
 
     const parsedResponse = parsePayload(r.payload.value());
     if (!compareDigest(Buffer.from(parsedResponse.v, 'base64'), serverSignature)) {
-      callback(new MongoDriverError('Server returned an invalid signature'));
+      callback(new MongoRuntimeError('Server returned an invalid signature'));
       return;
     }
 

src/cmap/commands.ts

@@ -5,7 +5,7 @@ import { OP_QUERY, OP_GETMORE, OP_KILL_CURSORS, OP_MSG } from './wire_protocol/c
 import type { Long, Document, BSONSerializeOptions } from '../bson';
 import type { ClientSession } from '../sessions';
 import type { CommandOptions } from './connection';
-import { MongoDriverError, MongoInvalidArgumentError } from '../error';
+import { MongoRuntimeError, MongoInvalidArgumentError } from '../error';
 
 // Incrementing request id
 let _requestId = 0;
@@ -78,14 +78,14 @@ export class Query {
   constructor(ns: string, query: Document, options: OpQueryOptions) {
     // Basic options needed to be passed in
     // TODO(NODE-3483): Replace with MongoCommandError
-    if (ns == null) throw new MongoDriverError('Namespace must be specified for query');
+    if (ns == null) throw new MongoRuntimeError('Namespace must be specified for query');
     // TODO(NODE-3483): Replace with MongoCommandError
-    if (query == null) throw new MongoDriverError('A query document must be specified for query');
+    if (query == null) throw new MongoRuntimeError('A query document must be specified for query');
 
     // Validate that we are not passing 0x00 in the collection name
     if (ns.indexOf('\x00') !== -1) {
       // TODO(NODE-3483): Use MongoNamespace static method
-      throw new MongoDriverError('Namespace cannot contain a null character');
+      throw new MongoRuntimeError('Namespace cannot contain a null character');
     }
 
     // Basic options
@@ -858,7 +858,7 @@ export class BinMsg {
         // It was decided that no driver makes use of payload type 1
 
         // TODO(NODE-3483): Replace with MongoDeprecationError
-        throw new MongoDriverError('OP_MSG Payload Type 1 detected unsupported protocol');
+        throw new MongoRuntimeError('OP_MSG Payload Type 1 detected unsupported protocol');
       }
     }
 

src/cmap/connect.ts

@@ -8,7 +8,7 @@ import {
   MongoCompatibilityError,
   MongoInvalidArgumentError,
   MongoServerError,
-  MongoDriverError
+  MongoRuntimeError
 } from '../error';
 import { AUTH_PROVIDERS, AuthMechanism } from './auth/defaultAuthProviders';
 import { AuthContext } from './auth/auth_provider';
@@ -144,7 +144,7 @@ function performInitialHandshake(
         }
         if (!response.serviceId) {
           return callback(
-            new MongoDriverError(
+            new MongoCompatibilityError(
               'Driver attempted to initialize in load balancing mode, ' +
                 'but the server does not support this mode.'
             )
@@ -284,7 +284,8 @@ function parseConnectOptions(options: ConnectionOptions): SocketConnectOpts {
   } else {
     // This should never happen since we set up HostAddresses
     // But if we don't throw here the socket could hang until timeout
-    throw new MongoDriverError(`Unexpected HostAddress ${JSON.stringify(hostAddress)}`);
+    // TODO(NODE-3483)
+    throw new MongoRuntimeError(`Unexpected HostAddress ${JSON.stringify(hostAddress)}`);
   }
 }
 

src/cmap/connection.ts

@@ -17,7 +17,7 @@ import {
   HostAddress
 } from '../utils';
 import {
-  MongoDriverError,
+  MongoRuntimeError,
   MongoMissingDependencyError,
   MongoCompatibilityError,
   MongoNetworkError,
@@ -363,7 +363,7 @@ export class Connection extends TypedEventEmitter<ConnectionEvents> {
   ): void {
     if (!(ns instanceof MongoDBNamespace)) {
       // TODO(NODE-3483): Replace this with a MongoCommandError
-      throw new MongoDriverError('Must provide a MongoDBNamespace instance');
+      throw new MongoRuntimeError('Must provide a MongoDBNamespace instance');
     }
 
     const readPreference = getReadPreference(cmd, options);
@@ -515,7 +515,7 @@ export class Connection extends TypedEventEmitter<ConnectionEvents> {
     const wireVersion = maxWireVersion(this);
     if (!cursorId) {
       // TODO(NODE-3483): Replace this with a MongoCommandError
-      callback(new MongoDriverError('Invalid internal cursor state, no known cursor id'));
+      callback(new MongoRuntimeError('Invalid internal cursor state, no known cursor id'));
       return;
     }
 
@@ -570,7 +570,7 @@ export class Connection extends TypedEventEmitter<ConnectionEvents> {
   ): void {
     if (!cursorIds || !Array.isArray(cursorIds)) {
       // TODO(NODE-3483): Replace this with a MongoCommandError
-      throw new MongoDriverError(`Invalid list of cursor ids provided: ${cursorIds}`);
+      throw new MongoRuntimeError(`Invalid list of cursor ids provided: ${cursorIds}`);
     }
 
     if (maxWireVersion(this) < 4) {
@@ -600,7 +600,8 @@ export class Connection extends TypedEventEmitter<ConnectionEvents> {
 
         if (!Array.isArray(response.documents) || response.documents.length === 0) {
           return callback(
-            new MongoDriverError(
+            // TODO(NODE-3483)
+            new MongoRuntimeError(
               `invalid killCursors result returned for cursor id ${cursorIds[0]}`
             )
           );

src/cmap/connection_pool.ts

@@ -5,12 +5,7 @@ import { Logger } from '../logger';
 import { ConnectionPoolMetrics } from './metrics';
 import { connect } from './connect';
 import { eachAsync, makeCounter, Callback } from '../utils';
-import {
-  MongoError,
-  MongoInvalidArgumentError,
-  MongoDriverError,
-  MongoRuntimeError
-} from '../error';
+import { MongoError, MongoInvalidArgumentError, MongoRuntimeError } from '../error';
 import { PoolClosedError, WaitQueueTimeoutError } from './errors';
 import {
   ConnectionPoolCreatedEvent,
@@ -355,7 +350,8 @@ export class ConnectionPool extends TypedEventEmitter<ConnectionPoolEvents> {
       // Only need to worry if the generation exists, since it should
       // always be there but typescript needs the check.
       if (generation == null) {
-        throw new MongoDriverError('Service generations are required in load balancer mode.');
+        // TODO(NODE-3483)
+        throw new MongoRuntimeError('Service generations are required in load balancer mode.');
       } else {
         // Increment the generation for the service id.
         this.serviceGenerations.set(sid, generation + 1);