mongodb 4.0.0 → 4.1.2

package/src/change_stream.ts

@@ -1,5 +1,12 @@
 import Denque = require('denque');
-import { MongoError, AnyError, isResumableError, MongoDriverError } from './error';
+import {
+  MongoError,
+  AnyError,
+  isResumableError,
+  MongoRuntimeError,
+  MongoAPIError,
+  MongoChangeStreamError
+} from './error';
 import { AggregateOperation, AggregateOptions } from './operations/aggregate';
 import {
   maxWireVersion,
@@ -191,9 +198,9 @@ export type ChangeStreamEvents = {
  * Creates a new Change Stream instance. Normally created using {@link Collection#watch|Collection.watch()}.
  * @public
  */
-export class ChangeStream<TSchema extends Document = Document> extends TypedEventEmitter<
-  ChangeStreamEvents
-> {
+export class ChangeStream<
+  TSchema extends Document = Document
+> extends TypedEventEmitter<ChangeStreamEvents> {
   pipeline: Document[];
   options: ChangeStreamOptions;
   parent: MongoClient | Db | Collection;
@@ -203,7 +210,7 @@ export class ChangeStream<TSchema extends Document = Document> extends TypedEven
   cursor?: ChangeStreamCursor<TSchema>;
   streamOptions?: CursorStreamOptions;
   /** @internal */
-  [kResumeQueue]: Denque;
+  [kResumeQueue]: Denque<Callback<ChangeStreamCursor<TSchema>>>;
   /** @internal */
   [kCursorStream]?: Readable;
   /** @internal */
@@ -259,8 +266,8 @@ export class ChangeStream<TSchema extends Document = Document> extends TypedEven
     } else if (parent instanceof MongoClient) {
       this.type = CHANGE_DOMAIN_TYPES.CLUSTER;
     } else {
-      throw new MongoDriverError(
-        'parent provided to ChangeStream constructor is not an instance of Collection, Db, or MongoClient'
+      throw new MongoChangeStreamError(
+        'Parent provided to ChangeStream constructor must be an instance of Collection, Db, or MongoClient'
       );
     }
 
@@ -364,7 +371,7 @@ export class ChangeStream<TSchema extends Document = Document> extends TypedEven
    */
   stream(options?: CursorStreamOptions): Readable {
     this.streamOptions = options;
-    if (!this.cursor) throw new MongoDriverError(NO_CURSOR_ERROR);
+    if (!this.cursor) throw new MongoChangeStreamError(NO_CURSOR_ERROR);
     return this.cursor.stream(options);
   }
 
@@ -487,15 +494,11 @@ export class ChangeStreamCursor<TSchema extends Document = Document> extends Abs
   }
 
   _initialize(session: ClientSession, callback: Callback<ExecutionResult>): void {
-    const aggregateOperation = new AggregateOperation(
-      { s: { namespace: this.namespace } },
-      this.pipeline,
-      {
-        ...this.cursorOptions,
-        ...this.options,
-        session
-      }
-    );
+    const aggregateOperation = new AggregateOperation(this.namespace, this.pipeline, {
+      ...this.cursorOptions,
+      ...this.options,
+      session
+    });
 
     executeOperation(this.topology, aggregateOperation, (err, response) => {
       if (err || response == null) {
@@ -545,8 +548,9 @@ const CHANGE_STREAM_EVENTS = [
 
 function setIsEmitter<TSchema>(changeStream: ChangeStream<TSchema>): void {
   if (changeStream[kMode] === 'iterator') {
-    throw new MongoDriverError(
-      'Cannot use ChangeStream as an EventEmitter after using as an iterator'
+    // TODO(NODE-3485): Replace with MongoChangeStreamModeError
+    throw new MongoAPIError(
+      'ChangeStream cannot be used as an EventEmitter after being used as an iterator'
     );
   }
   changeStream[kMode] = 'emitter';
@@ -554,8 +558,9 @@ function setIsEmitter<TSchema>(changeStream: ChangeStream<TSchema>): void {
 
 function setIsIterator<TSchema>(changeStream: ChangeStream<TSchema>): void {
   if (changeStream[kMode] === 'emitter') {
-    throw new MongoDriverError(
-      'Cannot use ChangeStream as iterator after using as an EventEmitter'
+    // TODO(NODE-3485): Replace with MongoChangeStreamModeError
+    throw new MongoAPIError(
+      'ChangeStream cannot be used as an iterator after being used as an EventEmitter'
     );
   }
   changeStream[kMode] = 'iterator';
@@ -632,7 +637,8 @@ function waitForTopologyConnected(
     }
 
     if (calculateDurationInMs(start) > timeout) {
-      return callback(new MongoDriverError('Timed out waiting for connection'));
+      // TODO(NODE-3497): Replace with MongoNetworkTimeoutError
+      return callback(new MongoRuntimeError('Timed out waiting for connection'));
     }
 
     waitForTopologyConnected(topology, options, callback);
@@ -678,17 +684,23 @@ function processNewChange<TSchema>(
   callback?: Callback<ChangeStreamDocument<TSchema>>
 ) {
   if (changeStream[kClosed]) {
-    if (callback) callback(new MongoDriverError(CHANGESTREAM_CLOSED_ERROR));
+    // TODO(NODE-3485): Replace with MongoChangeStreamClosedError
+    if (callback) callback(new MongoAPIError(CHANGESTREAM_CLOSED_ERROR));
     return;
   }
 
   // a null change means the cursor has been notified, implicitly closing the change stream
   if (change == null) {
-    return closeWithError(changeStream, new MongoDriverError(CHANGESTREAM_CLOSED_ERROR), callback);
+    // TODO(NODE-3485): Replace with MongoChangeStreamClosedError
+    return closeWithError(changeStream, new MongoRuntimeError(CHANGESTREAM_CLOSED_ERROR), callback);
   }
 
   if (change && !change._id) {
-    return closeWithError(changeStream, new MongoDriverError(NO_RESUME_TOKEN_ERROR), callback);
+    return closeWithError(
+      changeStream,
+      new MongoChangeStreamError(NO_RESUME_TOKEN_ERROR),
+      callback
+    );
   }
 
   // cache the resume token
@@ -712,7 +724,8 @@ function processError<TSchema>(
 
   // If the change stream has been closed explicitly, do not process error.
   if (changeStream[kClosed]) {
-    if (callback) callback(new MongoDriverError(CHANGESTREAM_CLOSED_ERROR));
+    // TODO(NODE-3485): Replace with MongoChangeStreamClosedError
+    if (callback) callback(new MongoAPIError(CHANGESTREAM_CLOSED_ERROR));
     return;
   }
 
@@ -772,7 +785,8 @@ function processError<TSchema>(
  */
 function getCursor<T>(changeStream: ChangeStream<T>, callback: Callback<ChangeStreamCursor<T>>) {
   if (changeStream[kClosed]) {
-    callback(new MongoDriverError(CHANGESTREAM_CLOSED_ERROR));
+    // TODO(NODE-3485): Replace with MongoChangeStreamClosedError
+    callback(new MongoAPIError(CHANGESTREAM_CLOSED_ERROR));
     return;
   }
 
@@ -795,13 +809,16 @@ function getCursor<T>(changeStream: ChangeStream<T>, callback: Callback<ChangeSt
 function processResumeQueue<TSchema>(changeStream: ChangeStream<TSchema>, err?: Error) {
   while (changeStream[kResumeQueue].length) {
     const request = changeStream[kResumeQueue].pop();
+    if (!request) break; // Should never occur but TS can't use the length check in the while condition
+
     if (!err) {
       if (changeStream[kClosed]) {
-        request(new MongoDriverError(CHANGESTREAM_CLOSED_ERROR));
+        // TODO(NODE-3485): Replace with MongoChangeStreamClosedError
+        request(new MongoAPIError(CHANGESTREAM_CLOSED_ERROR));
         return;
       }
       if (!changeStream.cursor) {
-        request(new MongoDriverError(NO_CURSOR_ERROR));
+        request(new MongoChangeStreamError(NO_CURSOR_ERROR));
         return;
       }
     }

package/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,6 +54,7 @@ export class AuthProvider {
    * @param callback - The callback to return the result from the authentication
    */
   auth(context: AuthContext, callback: Callback): void {
-    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'));
   }
 }

package/src/cmap/auth/gssapi.ts

@@ -1,5 +1,11 @@
 import { AuthProvider, AuthContext } from './auth_provider';
-import { MongoDriverError, MongoError } from '../../error';
+import {
+  MongoRuntimeError,
+  MongoInvalidArgumentError,
+  MongoMissingCredentialsError,
+  MongoError,
+  MongoMissingDependencyError
+} from '../../error';
 import { Kerberos, KerberosClient } from '../../deps';
 import { Callback, ns } from '../../utils';
 import type { Document } from '../../bson';
@@ -15,7 +21,10 @@ import * as dns from 'dns';
 export class GSSAPI extends AuthProvider {
   auth(authContext: AuthContext, callback: Callback): void {
     const { connection, credentials } = authContext;
-    if (credentials == null) return callback(new MongoDriverError('credentials required'));
+    if (credentials == null)
+      return callback(
+        new MongoMissingCredentialsError('Credentials required for GSSAPI authentication')
+      );
     const { username } = credentials;
     function externalCommand(
       command: Document,
@@ -25,7 +34,7 @@ export class GSSAPI extends AuthProvider {
     }
     makeKerberosClient(authContext, (err, client) => {
       if (err) return callback(err);
-      if (client == null) return callback(new MongoDriverError('gssapi client missing'));
+      if (client == null) return callback(new MongoMissingDependencyError('GSSAPI client missing'));
       client.step('', (err, payload) => {
         if (err) return callback(err);
 
@@ -66,7 +75,7 @@ function makeKerberosClient(authContext: AuthContext, callback: Callback<Kerbero
   const { credentials } = authContext;
   if (!hostAddress || typeof hostAddress.host !== 'string' || !credentials) {
     return callback(
-      new MongoDriverError('Connection must have host and port and credentials defined.')
+      new MongoInvalidArgumentError('Connection must have host and port and credentials defined.')
     );
   }
 
@@ -97,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);
       });
     }

package/src/cmap/auth/mongo_credentials.ts

@@ -1,7 +1,7 @@
 // Resolves the default auth mechanism according to
 
 import type { Document } from '../../bson';
-import { MongoDriverError } from '../../error';
+import { MongoAPIError, MongoMissingCredentialsError } from '../../error';
 import { AuthMechanism } from './defaultAuthProviders';
 
 // https://github.com/mongodb/specifications/blob/master/source/auth/auth.rst
@@ -25,6 +25,14 @@ function getDefaultAuthMechanism(ismaster?: Document): AuthMechanism {
   return AuthMechanism.MONGODB_CR;
 }
 
+/** @public */
+export interface AuthMechanismProperties extends Document {
+  SERVICE_NAME?: string;
+  SERVICE_REALM?: string;
+  CANONICALIZE_HOST_NAME?: boolean;
+  AWS_SESSION_TOKEN?: string;
+}
+
 /** @public */
 export interface MongoCredentialsOptions {
   username: string;
@@ -32,7 +40,7 @@ export interface MongoCredentialsOptions {
   source: string;
   db?: string;
   mechanism?: AuthMechanism;
-  mechanismProperties: Document;
+  mechanismProperties: AuthMechanismProperties;
 }
 
 /**
@@ -49,7 +57,7 @@ export class MongoCredentials {
   /** The method used to authenticate */
   readonly mechanism: AuthMechanism;
   /** Special properties used by some types of auth mechanisms */
-  readonly mechanismProperties: Document;
+  readonly mechanismProperties: AuthMechanismProperties;
 
   constructor(options: MongoCredentialsOptions) {
     this.username = options.username;
@@ -70,7 +78,10 @@ export class MongoCredentials {
         this.password = process.env.AWS_SECRET_ACCESS_KEY;
       }
 
-      if (!this.mechanismProperties.AWS_SESSION_TOKEN && process.env.AWS_SESSION_TOKEN) {
+      if (
+        this.mechanismProperties.AWS_SESSION_TOKEN == null &&
+        process.env.AWS_SESSION_TOKEN != null
+      ) {
         this.mechanismProperties = {
           ...this.mechanismProperties,
           AWS_SESSION_TOKEN: process.env.AWS_SESSION_TOKEN
@@ -122,7 +133,7 @@ export class MongoCredentials {
         this.mechanism === AuthMechanism.MONGODB_SCRAM_SHA256) &&
       !this.username
     ) {
-      throw new MongoDriverError(`Username required for mechanism '${this.mechanism}'`);
+      throw new MongoMissingCredentialsError(`Username required for mechanism '${this.mechanism}'`);
     }
 
     if (
@@ -131,14 +142,16 @@ export class MongoCredentials {
       this.mechanism === AuthMechanism.MONGODB_X509
     ) {
       if (this.source != null && this.source !== '$external') {
-        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) {
-      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) {
@@ -146,7 +159,8 @@ export class MongoCredentials {
         Reflect.set(this, 'password', undefined);
         return;
       }
-      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`);
     }
   }
 

package/src/cmap/auth/mongocr.ts

@@ -1,13 +1,13 @@
 import * as crypto from 'crypto';
 import { AuthProvider, AuthContext } from './auth_provider';
 import { Callback, ns } from '../../utils';
-import { MongoDriverError } from '../../error';
+import { MongoMissingCredentialsError } from '../../error';
 
 export class MongoCR extends AuthProvider {
   auth(authContext: AuthContext, callback: Callback): void {
     const { connection, credentials } = authContext;
     if (!credentials) {
-      return callback(new MongoDriverError('AuthContext must provide credentials.'));
+      return callback(new MongoMissingCredentialsError('AuthContext must provide credentials.'));
     }
     const username = credentials.username;
     const password = credentials.password;
@@ -24,7 +24,7 @@ export class MongoCR extends AuthProvider {
         let md5 = crypto.createHash('md5');
 
         // Generate keys used for authentication
-        md5.update(username + ':mongo:' + password, 'utf8');
+        md5.update(`${username}:mongo:${password}`, 'utf8');
         const hash_password = md5.digest('hex');
 
         // Final key

package/src/cmap/auth/mongodb_aws.ts

@@ -4,12 +4,17 @@ import * as url from 'url';
 import * as BSON from '../../bson';
 import { AuthProvider, AuthContext } from './auth_provider';
 import { MongoCredentials } from './mongo_credentials';
-import { MongoDriverError } from '../../error';
+import {
+  MongoRuntimeError,
+  MongoMissingCredentialsError,
+  MongoCompatibilityError
+} from '../../error';
 import { maxWireVersion, Callback, ns } from '../../utils';
 import type { BSONSerializeOptions } from '../../bson';
 
 import { aws4 } from '../../deps';
 import { AuthMechanism } from './defaultAuthProviders';
+import type { Binary } from 'bson';
 
 const ASCII_N = 110;
 const AWS_RELATIVE_URI = 'http://169.254.170.2';
@@ -32,7 +37,7 @@ export class MongoDBAWS extends AuthProvider {
   auth(authContext: AuthContext, callback: Callback): void {
     const { connection, credentials } = authContext;
     if (!credentials) {
-      return callback(new MongoDriverError('AuthContext must provide credentials.'));
+      return callback(new MongoMissingCredentialsError('AuthContext must provide credentials.'));
     }
 
     if ('kModuleError' in aws4) {
@@ -42,7 +47,9 @@ export class MongoDBAWS extends AuthProvider {
 
     if (maxWireVersion(connection) < 9) {
       callback(
-        new MongoDriverError('MONGODB-AWS authentication requires MongoDB version 4.4 or later')
+        new MongoCompatibilityError(
+          'MONGODB-AWS authentication requires MongoDB version 4.4 or later'
+        )
       );
       return;
     }
@@ -58,10 +65,19 @@ export class MongoDBAWS extends AuthProvider {
       return;
     }
 
-    const username = credentials.username;
-    const password = credentials.password;
+    const accessKeyId = credentials.username;
+    const secretAccessKey = credentials.password;
+    const sessionToken = credentials.mechanismProperties.AWS_SESSION_TOKEN;
+
+    // If all three defined, include sessionToken, else include username and pass, else no credentials
+    const awsCredentials =
+      accessKeyId && secretAccessKey && sessionToken
+        ? { accessKeyId, secretAccessKey, sessionToken }
+        : accessKeyId && secretAccessKey
+        ? { accessKeyId, secretAccessKey }
+        : undefined;
+
     const db = credentials.source;
-    const token = credentials.mechanismProperties.AWS_SESSION_TOKEN;
     crypto.randomBytes(32, (err, nonce) => {
       if (err) {
         callback(err);
@@ -77,24 +93,30 @@ export class MongoDBAWS extends AuthProvider {
       connection.command(ns(`${db}.$cmd`), saslStart, undefined, (err, res) => {
         if (err) return callback(err);
 
-        const serverResponse = BSON.deserialize(res.payload.buffer, bsonOptions);
+        const serverResponse = BSON.deserialize(res.payload.buffer, bsonOptions) as {
+          s: Binary;
+          h: string;
+        };
         const host = serverResponse.h;
         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;
         }
 
@@ -114,18 +136,15 @@ export class MongoDBAWS extends AuthProvider {
             path: '/',
             body
           },
-          {
-            accessKeyId: username,
-            secretAccessKey: password,
-            token
-          }
+          awsCredentials
         );
 
-        const authorization = options.headers.Authorization;
-        const date = options.headers['X-Amz-Date'];
-        const payload: AWSSaslContinuePayload = { a: authorization, d: date };
-        if (token) {
-          payload.t = token;
+        const payload: AWSSaslContinuePayload = {
+          a: options.headers.Authorization,
+          d: options.headers['X-Amz-Date']
+        };
+        if (sessionToken) {
+          payload.t = sessionToken;
         }
 
         const saslContinue = {
@@ -140,16 +159,20 @@ export class MongoDBAWS extends AuthProvider {
   }
 }
 
-interface AWSCredentials {
+interface AWSTempCredentials {
   AccessKeyId?: string;
   SecretAccessKey?: string;
   Token?: string;
+  RoleArn?: string;
+  Expiration?: Date;
 }
 
 function makeTempCredentials(credentials: MongoCredentials, callback: Callback<MongoCredentials>) {
-  function done(creds: AWSCredentials) {
+  function done(creds: AWSTempCredentials) {
     if (!creds.AccessKeyId || !creds.SecretAccessKey || !creds.Token) {
-      callback(new MongoDriverError('Could not obtain temporary MONGODB-AWS credentials'));
+      callback(
+        new MongoMissingCredentialsError('Could not obtain temporary MONGODB-AWS credentials')
+      );
       return;
     }
 
@@ -172,6 +195,7 @@ function makeTempCredentials(credentials: MongoCredentials, callback: Callback<M
   if (process.env.AWS_CONTAINER_CREDENTIALS_RELATIVE_URI) {
     request(
       `${AWS_RELATIVE_URI}${process.env.AWS_CONTAINER_CREDENTIALS_RELATIVE_URI}`,
+      undefined,
       (err, res) => {
         if (err) return callback(err);
         done(res);
@@ -228,27 +252,15 @@ interface RequestOptions {
   headers?: http.OutgoingHttpHeaders;
 }
 
-function request(uri: string, callback: Callback): void;
-function request(uri: string, options: RequestOptions, callback: Callback): void;
-function request(uri: string, _options: RequestOptions | Callback, _callback?: Callback) {
-  let options = _options as RequestOptions;
-  if ('function' === typeof _options) {
-    options = {};
-  }
-
-  let callback: Callback = _options as Callback;
-  if (_callback) {
-    callback = _callback;
-  }
-
-  options = Object.assign(
+function request(uri: string, _options: RequestOptions | undefined, callback: Callback) {
+  const options = Object.assign(
     {
       method: 'GET',
       timeout: 10000,
       json: true
     },
     url.parse(uri),
-    options
+    _options
   );
 
   const req = http.request(options, res => {
@@ -266,7 +278,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}"`));
       }
     });
   });

package/src/cmap/auth/plain.ts

@@ -1,13 +1,13 @@
 import { Binary } from '../../bson';
 import { AuthProvider, AuthContext } from './auth_provider';
-import { MongoDriverError } from '../../error';
+import { MongoMissingCredentialsError } from '../../error';
 import { Callback, ns } from '../../utils';
 
 export class Plain extends AuthProvider {
   auth(authContext: AuthContext, callback: Callback): void {
     const { connection, credentials } = authContext;
     if (!credentials) {
-      return callback(new MongoDriverError('AuthContext must provide credentials.'));
+      return callback(new MongoMissingCredentialsError('AuthContext must provide credentials.'));
     }
     const username = credentials.username;
     const password = credentials.password;