mongodb 4.0.0 → 4.1.2

package/src/cmap/auth/scram.ts

@@ -1,6 +1,12 @@
 import * as crypto from 'crypto';
 import { Binary, Document } from '../../bson';
-import { AnyError, MongoDriverError, MongoServerError } from '../../error';
+import {
+  AnyError,
+  MongoRuntimeError,
+  MongoServerError,
+  MongoInvalidArgumentError,
+  MongoMissingCredentialsError
+} from '../../error';
 import { AuthProvider, AuthContext } from './auth_provider';
 import { Callback, ns, emitWarning } from '../../utils';
 import type { MongoCredentials } from './mongo_credentials';
@@ -22,7 +28,7 @@ class ScramSHA extends AuthProvider {
     const cryptoMethod = this.cryptoMethod;
     const credentials = authContext.credentials;
     if (!credentials) {
-      return callback(new MongoDriverError('AuthContext must provide credentials.'));
+      return callback(new MongoMissingCredentialsError('AuthContext must provide credentials.'));
     }
     if (cryptoMethod === 'sha256' && saslprep == null) {
       emitWarning('Warning: no saslprep library specified. Passwords will not be sanitized');
@@ -103,10 +109,12 @@ function makeFirstMessage(
 function executeScram(cryptoMethod: CryptoMethod, authContext: AuthContext, callback: Callback) {
   const { connection, credentials } = authContext;
   if (!credentials) {
-    return callback(new MongoDriverError('AuthContext must provide credentials.'));
+    return callback(new MongoMissingCredentialsError('AuthContext must provide credentials.'));
   }
   if (!authContext.nonce) {
-    return callback(new MongoDriverError('AuthContext must contain a valid nonce property'));
+    return callback(
+      new MongoInvalidArgumentError('AuthContext must contain a valid nonce property')
+    );
   }
   const nonce = authContext.nonce;
   const db = credentials.source;
@@ -131,10 +139,10 @@ function continueScramConversation(
   const connection = authContext.connection;
   const credentials = authContext.credentials;
   if (!credentials) {
-    return callback(new MongoDriverError('AuthContext must provide credentials.'));
+    return callback(new MongoMissingCredentialsError('AuthContext must provide credentials.'));
   }
   if (!authContext.nonce) {
-    return callback(new MongoDriverError('Unable to continue SCRAM without valid nonce'));
+    return callback(new MongoInvalidArgumentError('Unable to continue SCRAM without valid nonce'));
   }
   const nonce = authContext.nonce;
 
@@ -161,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;
@@ -170,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;
   }
 
@@ -209,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;
     }
 
@@ -240,15 +250,15 @@ function parsePayload(payload: string) {
 
 function passwordDigest(username: string, password: string) {
   if (typeof username !== 'string') {
-    throw new MongoDriverError('username must be a string');
+    throw new MongoInvalidArgumentError('Username must be a string');
   }
 
   if (typeof password !== 'string') {
-    throw new MongoDriverError('password must be a string');
+    throw new MongoInvalidArgumentError('Password must be a string');
   }
 
   if (password.length === 0) {
-    throw new MongoDriverError('password cannot be empty');
+    throw new MongoInvalidArgumentError('Password cannot be empty');
   }
 
   const md5 = crypto.createHash('md5');
@@ -303,7 +313,7 @@ const hiLengthMap = {
 function HI(data: string, salt: Buffer, iterations: number, cryptoMethod: CryptoMethod) {
   // omit the work if already generated
   const key = [data, salt.toString('base64'), iterations].join('_');
-  if (_hiCache[key] !== undefined) {
+  if (_hiCache[key] != null) {
     return _hiCache[key];
   }
 

package/src/cmap/auth/x509.ts

@@ -1,5 +1,5 @@
 import { AuthProvider, AuthContext } from './auth_provider';
-import { MongoDriverError } from '../../error';
+import { MongoMissingCredentialsError } from '../../error';
 import type { Document } from '../../bson';
 import { Callback, ns } from '../../utils';
 import type { MongoCredentials } from './mongo_credentials';
@@ -9,7 +9,7 @@ export class X509 extends AuthProvider {
   prepare(handshakeDoc: HandshakeDocument, authContext: AuthContext, callback: Callback): void {
     const { credentials } = authContext;
     if (!credentials) {
-      return callback(new MongoDriverError('AuthContext must provide credentials.'));
+      return callback(new MongoMissingCredentialsError('AuthContext must provide credentials.'));
     }
     Object.assign(handshakeDoc, {
       speculativeAuthenticate: x509AuthenticateCommand(credentials)
@@ -22,7 +22,7 @@ export class X509 extends AuthProvider {
     const connection = authContext.connection;
     const credentials = authContext.credentials;
     if (!credentials) {
-      return callback(new MongoDriverError('AuthContext must provide credentials.'));
+      return callback(new MongoMissingCredentialsError('AuthContext must provide credentials.'));
     }
     const response = authContext.response;
 

package/src/cmap/command_monitoring_events.ts

@@ -1,8 +1,7 @@
 import { GetMore, KillCursor, Msg, WriteProtocolMessageType } from './commands';
 import { calculateDurationInMs, deepCopy } from '../utils';
-import type { ConnectionPool } from './connection_pool';
 import type { Connection } from './connection';
-import type { Document } from '../bson';
+import type { Document, ObjectId } from '../bson';
 
 /**
  * An event indicating the start of a given
@@ -17,6 +16,7 @@ export class CommandStartedEvent {
   command: Document;
   address: string;
   connectionId?: string | number;
+  serviceId?: ObjectId;
 
   /**
    * Create a started event
@@ -25,10 +25,10 @@ export class CommandStartedEvent {
    * @param pool - the pool that originated the command
    * @param command - the command
    */
-  constructor(pool: Connection | ConnectionPool, command: WriteProtocolMessageType) {
+  constructor(connection: Connection, command: WriteProtocolMessageType) {
     const cmd = extractCommand(command);
     const commandName = extractCommandName(cmd);
-    const { address, connectionId } = extractConnectionDetails(pool);
+    const { address, connectionId, serviceId } = extractConnectionDetails(connection);
 
     // TODO: remove in major revision, this is not spec behavior
     if (SENSITIVE_COMMANDS.has(commandName)) {
@@ -38,11 +38,17 @@ export class CommandStartedEvent {
 
     this.address = address;
     this.connectionId = connectionId;
+    this.serviceId = serviceId;
     this.requestId = command.requestId;
     this.databaseName = databaseName(command);
     this.commandName = commandName;
     this.command = maybeRedact(commandName, cmd, cmd);
   }
+
+  /* @internal */
+  get hasServiceId(): boolean {
+    return !!this.serviceId;
+  }
 }
 
 /**
@@ -57,6 +63,7 @@ export class CommandSucceededEvent {
   duration: number;
   commandName: string;
   reply: unknown;
+  serviceId?: ObjectId;
 
   /**
    * Create a succeeded event
@@ -68,22 +75,28 @@ export class CommandSucceededEvent {
    * @param started - a high resolution tuple timestamp of when the command was first sent, to calculate duration
    */
   constructor(
-    pool: Connection | ConnectionPool,
+    connection: Connection,
     command: WriteProtocolMessageType,
     reply: Document | undefined,
     started: number
   ) {
     const cmd = extractCommand(command);
     const commandName = extractCommandName(cmd);
-    const { address, connectionId } = extractConnectionDetails(pool);
+    const { address, connectionId, serviceId } = extractConnectionDetails(connection);
 
     this.address = address;
     this.connectionId = connectionId;
+    this.serviceId = serviceId;
     this.requestId = command.requestId;
     this.commandName = commandName;
     this.duration = calculateDurationInMs(started);
     this.reply = maybeRedact(commandName, cmd, extractReply(command, reply));
   }
+
+  /* @internal */
+  get hasServiceId(): boolean {
+    return !!this.serviceId;
+  }
 }
 
 /**
@@ -98,6 +111,8 @@ export class CommandFailedEvent {
   duration: number;
   commandName: string;
   failure: Error;
+  serviceId?: ObjectId;
+
   /**
    * Create a failure event
    *
@@ -108,23 +123,29 @@ export class CommandFailedEvent {
    * @param started - a high resolution tuple timestamp of when the command was first sent, to calculate duration
    */
   constructor(
-    pool: Connection | ConnectionPool,
+    connection: Connection,
     command: WriteProtocolMessageType,
     error: Error | Document,
     started: number
   ) {
     const cmd = extractCommand(command);
     const commandName = extractCommandName(cmd);
-    const { address, connectionId } = extractConnectionDetails(pool);
+    const { address, connectionId, serviceId } = extractConnectionDetails(connection);
 
     this.address = address;
     this.connectionId = connectionId;
+    this.serviceId = serviceId;
 
     this.requestId = command.requestId;
     this.commandName = commandName;
     this.duration = calculateDurationInMs(started);
     this.failure = maybeRedact(commandName, cmd, error) as Error;
   }
+
+  /* @internal */
+  get hasServiceId(): boolean {
+    return !!this.serviceId;
+  }
 }
 
 /** Commands that we want to redact because of the sensitive nature of their contents */
@@ -212,7 +233,7 @@ function extractCommand(command: WriteProtocolMessageType): Document {
       // up-convert legacy find command
       result = { find: collectionName(command) };
       Object.keys(LEGACY_FIND_QUERY_MAP).forEach(key => {
-        if (typeof command.query[key] !== 'undefined') {
+        if (command.query[key] != null) {
           result[LEGACY_FIND_QUERY_MAP[key]] = deepCopy(command.query[key]);
         }
       });
@@ -220,7 +241,7 @@ function extractCommand(command: WriteProtocolMessageType): Document {
 
     Object.keys(LEGACY_FIND_OPTIONS_MAP).forEach(key => {
       const legacyKey = key as keyof typeof LEGACY_FIND_OPTIONS_MAP;
-      if (typeof command[legacyKey] !== 'undefined') {
+      if (command[legacyKey] != null) {
         result[LEGACY_FIND_OPTIONS_MAP[legacyKey]] = deepCopy(command[legacyKey]);
       }
     });
@@ -232,7 +253,7 @@ function extractCommand(command: WriteProtocolMessageType): Document {
       }
     });
 
-    if (typeof command.pre32Limit !== 'undefined') {
+    if (command.pre32Limit != null) {
       result.limit = command.pre32Limit;
     }
 
@@ -253,7 +274,7 @@ function extractCommand(command: WriteProtocolMessageType): Document {
 
   for (const k in command) {
     if (k === 'query') continue;
-    clonedCommand[k] = deepCopy(((command as unknown) as Record<string, unknown>)[k]);
+    clonedCommand[k] = deepCopy((command as unknown as Record<string, unknown>)[k]);
   }
   return command.query ? clonedQuery : clonedCommand;
 }
@@ -286,7 +307,7 @@ function extractReply(command: WriteProtocolMessageType, reply?: Document) {
   }
 
   // is this a legacy find command?
-  if (command.query && typeof command.query.$query !== 'undefined') {
+  if (command.query && command.query.$query != null) {
     return {
       ok: 1,
       cursor: {
@@ -300,13 +321,14 @@ function extractReply(command: WriteProtocolMessageType, reply?: Document) {
   return deepCopy(reply.result ? reply.result : reply);
 }
 
-function extractConnectionDetails(connection: Connection | ConnectionPool) {
+function extractConnectionDetails(connection: Connection) {
   let connectionId;
   if ('id' in connection) {
     connectionId = connection.id;
   }
   return {
     address: connection.address,
+    serviceId: connection.serviceId,
     connectionId
   };
 }

package/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 } from '../error';
+import { MongoRuntimeError, MongoInvalidArgumentError } from '../error';
 
 // Incrementing request id
 let _requestId = 0;
@@ -77,12 +77,15 @@ export class Query {
 
   constructor(ns: string, query: Document, options: OpQueryOptions) {
     // Basic options needed to be passed in
-    if (ns == null) throw new MongoDriverError('ns must be specified for query');
-    if (query == null) throw new MongoDriverError('query must be specified for query');
+    // TODO(NODE-3483): Replace with MongoCommandError
+    if (ns == null) throw new MongoRuntimeError('Namespace must be specified for query');
+    // TODO(NODE-3483): Replace with MongoCommandError
+    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) {
-      throw new MongoDriverError('namespace cannot contain a null character');
+      // TODO(NODE-3483): Use MongoNamespace static method
+      throw new MongoRuntimeError('Namespace cannot contain a null character');
     }
 
     // Basic options
@@ -664,7 +667,8 @@ export class Msg {
 
   constructor(ns: string, command: Document, options: OpQueryOptions) {
     // Basic options needed to be passed in
-    if (command == null) throw new MongoDriverError('query must be specified for query');
+    if (command == null)
+      throw new MongoInvalidArgumentError('Query document must be specified for query');
 
     // Basic options
     this.ns = ns;
@@ -852,7 +856,9 @@ export class BinMsg {
         this.index += bsonSize;
       } else if (payloadType === 1) {
         // It was decided that no driver makes use of payload type 1
-        throw new MongoDriverError('OP_MSG Payload Type 1 detected unsupported protocol');
+
+        // TODO(NODE-3483): Replace with MongoDeprecationError
+        throw new MongoRuntimeError('OP_MSG Payload Type 1 detected unsupported protocol');
       }
     }
 

package/src/cmap/connect.ts

@@ -5,8 +5,10 @@ import {
   MongoNetworkError,
   MongoNetworkTimeoutError,
   AnyError,
-  MongoDriverError,
-  MongoServerError
+  MongoCompatibilityError,
+  MongoInvalidArgumentError,
+  MongoServerError,
+  MongoRuntimeError
 } from '../error';
 import { AUTH_PROVIDERS, AuthMechanism } from './auth/defaultAuthProviders';
 import { AuthContext } from './auth/auth_provider';
@@ -18,10 +20,14 @@ import {
   MIN_SUPPORTED_SERVER_VERSION
 } from './wire_protocol/constants';
 import type { Document } from '../bson';
+import { Int32 } from '../bson';
 
 import type { Socket, SocketConnectOpts } from 'net';
 import type { TLSSocket, ConnectionOptions as TLSConnectionOpts } from 'tls';
-import { Int32 } from '../bson';
+
+const FAKE_MONGODB_SERVICE_ID =
+  typeof process.env.FAKE_MONGODB_SERVICE_ID === 'string' &&
+  process.env.FAKE_MONGODB_SERVICE_ID.toLowerCase() === 'true';
 
 /** @public */
 export type Stream = Socket | TLSSocket;
@@ -58,13 +64,13 @@ function checkSupportedServer(ismaster: Document, options: ConnectionOptions) {
     const message = `Server at ${options.hostAddress} reports minimum wire version ${JSON.stringify(
       ismaster.minWireVersion
     )}, but this version of the Node.js Driver requires at most ${MAX_SUPPORTED_WIRE_VERSION} (MongoDB ${MAX_SUPPORTED_SERVER_VERSION})`;
-    return new MongoDriverError(message);
+    return new MongoCompatibilityError(message);
   }
 
   const message = `Server at ${options.hostAddress} reports maximum wire version ${
     JSON.stringify(ismaster.maxWireVersion) ?? 0
   }, but this version of the Node.js Driver requires at least ${MIN_SUPPORTED_WIRE_VERSION} (MongoDB ${MIN_SUPPORTED_SERVER_VERSION})`;
-  return new MongoDriverError(message);
+  return new MongoCompatibilityError(message);
 }
 
 function performInitialHandshake(
@@ -85,7 +91,9 @@ function performInitialHandshake(
       !(credentials.mechanism === AuthMechanism.MONGODB_DEFAULT) &&
       !AUTH_PROVIDERS.get(credentials.mechanism)
     ) {
-      callback(new MongoDriverError(`authMechanism '${credentials.mechanism}' not supported`));
+      callback(
+        new MongoInvalidArgumentError(`AuthMechanism '${credentials.mechanism}' not supported`)
+      );
       return;
     }
   }
@@ -129,6 +137,21 @@ function performInitialHandshake(
         return;
       }
 
+      if (options.loadBalanced) {
+        // TODO: Durran: Remove when server support exists. (NODE-3431)
+        if (FAKE_MONGODB_SERVICE_ID) {
+          response.serviceId = response.topologyVersion.processId;
+        }
+        if (!response.serviceId) {
+          return callback(
+            new MongoCompatibilityError(
+              'Driver attempted to initialize in load balancing mode, ' +
+                'but the server does not support this mode.'
+            )
+          );
+        }
+      }
+
       // NOTE: This is metadata attached to the connection while porting away from
       //       handshake being done in the `Server` class. Likely, it should be
       //       relocated, or at very least restructured.
@@ -143,7 +166,9 @@ function performInitialHandshake(
         const provider = AUTH_PROVIDERS.get(resolvedCredentials.mechanism);
         if (!provider) {
           return callback(
-            new MongoDriverError(`No AuthProvider for ${resolvedCredentials.mechanism} defined.`)
+            new MongoInvalidArgumentError(
+              `No AuthProvider for ${resolvedCredentials.mechanism} defined.`
+            )
           );
         }
         provider.auth(authContext, err => {
@@ -166,6 +191,7 @@ export interface HandshakeDocument extends Document {
   client: ClientMetadata;
   compression: string[];
   saslSupportedMechs?: string;
+  loadBalanced: boolean;
 }
 
 function prepareHandshakeDocument(authContext: AuthContext, callback: Callback<HandshakeDocument>) {
@@ -177,7 +203,8 @@ function prepareHandshakeDocument(authContext: AuthContext, callback: Callback<H
     [serverApi?.version ? 'hello' : 'ismaster']: true,
     helloOk: true,
     client: options.metadata || makeClientMetadata(options),
-    compression: compressors
+    compression: compressors,
+    loadBalanced: options.loadBalanced
   };
 
   const credentials = authContext.credentials;
@@ -189,7 +216,9 @@ function prepareHandshakeDocument(authContext: AuthContext, callback: Callback<H
       if (!provider) {
         // This auth mechanism is always present.
         return callback(
-          new MongoDriverError(`No AuthProvider for ${AuthMechanism.MONGODB_SCRAM_SHA256} defined.`)
+          new MongoInvalidArgumentError(
+            `No AuthProvider for ${AuthMechanism.MONGODB_SCRAM_SHA256} defined.`
+          )
         );
       }
       return provider.prepare(handshakeDoc, authContext, callback);
@@ -197,7 +226,7 @@ function prepareHandshakeDocument(authContext: AuthContext, callback: Callback<H
     const provider = AUTH_PROVIDERS.get(credentials.mechanism);
     if (!provider) {
       return callback(
-        new MongoDriverError(`No AuthProvider for ${credentials.mechanism} defined.`)
+        new MongoInvalidArgumentError(`No AuthProvider for ${credentials.mechanism} defined.`)
       );
     }
     return provider.prepare(handshakeDoc, authContext, callback);
@@ -236,7 +265,7 @@ export const LEGAL_TCP_SOCKET_OPTIONS = [
 
 function parseConnectOptions(options: ConnectionOptions): SocketConnectOpts {
   const hostAddress = options.hostAddress;
-  if (!hostAddress) throw new MongoDriverError('HostAddress required');
+  if (!hostAddress) throw new MongoInvalidArgumentError('Option "hostAddress" is required');
 
   const result: Partial<net.TcpNetConnectOpts & net.IpcNetConnectOpts> = {};
   for (const name of LEGAL_TCP_SOCKET_OPTIONS) {
@@ -255,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)}`);
   }
 }