mongodb 4.1.1 → 4.2.0

package/src/bulk/common.ts

@@ -1,5 +1,12 @@
 import { PromiseProvider } from '../promise_provider';
-import { Long, ObjectId, Document, BSONSerializeOptions, resolveBSONOptions } from '../bson';
+import {
+  Long,
+  ObjectId,
+  Document,
+  BSONSerializeOptions,
+  resolveBSONOptions,
+  Timestamp
+} from '../bson';
 import {
   MongoWriteConcernError,
   AnyError,
@@ -383,6 +390,7 @@ export interface BulkWriteOperationError {
   index: number;
   code: number;
   errmsg: string;
+  errInfo: Document;
   op: Document | UpdateStatement | DeleteStatement;
 }
 
@@ -413,6 +421,11 @@ export class WriteError {
     return this.err.errmsg;
   }
 
+  /** WriteError details. */
+  get errInfo(): Document | undefined {
+    return this.err.errInfo;
+  }
+
   /** Returns the underlying operation that caused the error */
   getOperation(): Document {
     return this.err.op;
@@ -427,8 +440,13 @@ export class WriteError {
   }
 }
 
+/** Converts the number to a Long or returns it. */
+function longOrConvert(value: number | Long | Timestamp): Long | Timestamp {
+  return typeof value === 'number' ? Long.fromNumber(value) : value;
+}
+
 /** Merges results into shared data structure */
-function mergeBatchResults(
+export function mergeBatchResults(
   batch: Batch,
   bulkResult: BulkResult,
   err?: AnyError,
@@ -453,6 +471,7 @@ function mergeBatchResults(
       index: 0,
       code: result.code || 0,
       errmsg: result.message,
+      errInfo: result.errInfo,
       op: batch.operations[0]
     };
 
@@ -462,42 +481,37 @@ function mergeBatchResults(
     return;
   }
 
-  // Deal with opTime if available
+  // The server write command specification states that lastOp is an optional
+  // mongod only field that has a type of timestamp. Across various scarce specs
+  // where opTime is mentioned, it is an "opaque" object that can have a "ts" and
+  // "t" field with Timestamp and Long as their types respectively.
+  // The "lastOp" field of the bulk write result is never mentioned in the driver
+  // specifications or the bulk write spec, so we should probably just keep its
+  // value consistent since it seems to vary.
+  // See: https://github.com/mongodb/specifications/blob/master/source/driver-bulk-update.rst#results-object
   if (result.opTime || result.lastOp) {
-    const opTime = result.lastOp || result.opTime;
-    let lastOpTS = null;
-    let lastOpT = null;
+    let opTime = result.lastOp || result.opTime;
 
-    // We have a time stamp
-    if (opTime && opTime._bsontype === 'Timestamp') {
-      if (bulkResult.opTime == null) {
-        bulkResult.opTime = opTime;
-      } else if (opTime.greaterThan(bulkResult.opTime)) {
-        bulkResult.opTime = opTime;
-      }
-    } else {
-      // Existing TS
-      if (bulkResult.opTime) {
-        lastOpTS =
-          typeof bulkResult.opTime.ts === 'number'
-            ? Long.fromNumber(bulkResult.opTime.ts)
-            : bulkResult.opTime.ts;
-        lastOpT =
-          typeof bulkResult.opTime.t === 'number'
-            ? Long.fromNumber(bulkResult.opTime.t)
-            : bulkResult.opTime.t;
-      }
-
-      // Current OpTime TS
-      const opTimeTS = typeof opTime.ts === 'number' ? Long.fromNumber(opTime.ts) : opTime.ts;
-      const opTimeT = typeof opTime.t === 'number' ? Long.fromNumber(opTime.t) : opTime.t;
+    // If the opTime is a Timestamp, convert it to a consistent format to be
+    // able to compare easily. Converting to the object from a timestamp is
+    // much more straightforward than the other direction.
+    if (opTime._bsontype === 'Timestamp') {
+      opTime = { ts: opTime, t: Long.ZERO };
+    }
 
-      // Compare the opTime's
-      if (bulkResult.opTime == null) {
-        bulkResult.opTime = opTime;
-      } else if (opTimeTS.greaterThan(lastOpTS)) {
+    // If there's no lastOp, just set it.
+    if (!bulkResult.opTime) {
+      bulkResult.opTime = opTime;
+    } else {
+      // First compare the ts values and set if the opTimeTS value is greater.
+      const lastOpTS = longOrConvert(bulkResult.opTime.ts);
+      const opTimeTS = longOrConvert(opTime.ts);
+      if (opTimeTS.greaterThan(lastOpTS)) {
         bulkResult.opTime = opTime;
       } else if (opTimeTS.equals(lastOpTS)) {
+        // If the ts values are equal, then compare using the t values.
+        const lastOpT = longOrConvert(bulkResult.opTime.t);
+        const opTimeT = longOrConvert(opTime.t);
         if (opTimeT.greaterThan(lastOpT)) {
           bulkResult.opTime = opTime;
         }
@@ -555,6 +569,7 @@ function mergeBatchResults(
         index: batch.originalIndexes[result.writeErrors[i].index],
         code: result.writeErrors[i].code,
         errmsg: result.writeErrors[i].errmsg,
+        errInfo: result.writeErrors[i].errInfo,
         op: batch.operations[result.writeErrors[i].index]
       };
 
@@ -1201,9 +1216,15 @@ export abstract class BulkOperationBase {
     return batches;
   }
 
-  /** An internal helper method. Do not invoke directly. Will be going away in the future */
+  execute(options?: BulkWriteOptions): Promise<BulkWriteResult>;
+  execute(callback: Callback<BulkWriteResult>): void;
+  execute(options: BulkWriteOptions | undefined, callback: Callback<BulkWriteResult>): void;
+  execute(
+    options?: BulkWriteOptions | Callback<BulkWriteResult>,
+    callback?: Callback<BulkWriteResult>
+  ): Promise<BulkWriteResult> | void;
   execute(
-    options?: BulkWriteOptions,
+    options?: BulkWriteOptions | Callback<BulkWriteResult>,
     callback?: Callback<BulkWriteResult>
   ): Promise<BulkWriteResult> | void {
     if (typeof options === 'function') (callback = options), (options = {});

package/src/change_stream.ts

@@ -184,14 +184,14 @@ export interface UpdateDescription<TSchema extends Document = Document> {
 }
 
 /** @public */
-export type ChangeStreamEvents = {
+export type ChangeStreamEvents<TSchema extends Document = Document> = {
   resumeTokenChanged(token: ResumeToken): void;
-  init(response: Document): void;
-  more(response?: Document | undefined): void;
+  init(response: TSchema): void;
+  more(response?: TSchema | undefined): void;
   response(): void;
   end(): void;
   error(error: Error): void;
-  change(change: ChangeStreamDocument): void;
+  change(change: ChangeStreamDocument<TSchema>): void;
 } & AbstractCursorEvents;
 
 /**
@@ -199,7 +199,7 @@ export type ChangeStreamEvents = {
  * @public
  */
 export class ChangeStream<TSchema extends Document = Document> extends TypedEventEmitter<
-  ChangeStreamEvents
+  ChangeStreamEvents<TSchema>
 > {
   pipeline: Document[];
   options: ChangeStreamOptions;
@@ -210,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 */
@@ -809,6 +809,8 @@ 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]) {
         // TODO(NODE-3485): Replace with MongoChangeStreamClosedError

package/src/cmap/auth/mongo_credentials.ts

@@ -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

package/src/cmap/auth/mongodb_aws.ts

@@ -14,6 +14,7 @@ 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';
@@ -64,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);
@@ -83,7 +93,10 @@ 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) {
@@ -123,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 = {
@@ -149,14 +159,16 @@ 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 MongoMissingCredentialsError('Could not obtain temporary MONGODB-AWS credentials')
@@ -183,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);
@@ -239,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 => {

package/src/cmap/command_monitoring_events.ts

@@ -274,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;
 }

package/src/cmap/connection.ts

@@ -97,6 +97,7 @@ export interface CommandOptions extends BSONSerializeOptions {
   session?: ClientSession;
   documentsReturnedIn?: string;
   noResponse?: boolean;
+  omitReadPreference?: boolean;
 
   // FIXME: NODE-2802
   willRetryWrite?: boolean;

package/src/cmap/wire_protocol/constants.ts

@@ -1,7 +1,7 @@
-export const MIN_SUPPORTED_SERVER_VERSION = '2.6';
-export const MAX_SUPPORTED_SERVER_VERSION = '5.0';
-export const MIN_SUPPORTED_WIRE_VERSION = 2;
-export const MAX_SUPPORTED_WIRE_VERSION = 13;
+export const MIN_SUPPORTED_SERVER_VERSION = '3.6';
+export const MAX_SUPPORTED_SERVER_VERSION = '5.1';
+export const MIN_SUPPORTED_WIRE_VERSION = 6;
+export const MAX_SUPPORTED_WIRE_VERSION = 14;
 export const OP_REPLY = 1;
 export const OP_UPDATE = 2001;
 export const OP_INSERT = 2002;

package/src/collection.ts

@@ -676,12 +676,16 @@ export class Collection<TSchema extends Document = Document> {
    * @param options - Optional settings for the command
    * @param callback - An optional callback, a Promise will be returned if none is provided
    */
-  findOne(): Promise<TSchema | null>;
-  findOne(callback: Callback<TSchema | null>): void;
-  findOne(filter: Filter<TSchema>): Promise<TSchema | null>;
-  findOne(filter: Filter<TSchema>, callback: Callback<TSchema | null>): void;
-  findOne(filter: Filter<TSchema>, options: FindOptions): Promise<TSchema | null>;
-  findOne(filter: Filter<TSchema>, options: FindOptions, callback: Callback<TSchema | null>): void;
+  findOne(): Promise<WithId<TSchema> | null>;
+  findOne(callback: Callback<WithId<TSchema> | null>): void;
+  findOne(filter: Filter<TSchema>): Promise<WithId<TSchema> | null>;
+  findOne(filter: Filter<TSchema>, callback: Callback<WithId<TSchema> | null>): void;
+  findOne(filter: Filter<TSchema>, options: FindOptions): Promise<WithId<TSchema> | null>;
+  findOne(
+    filter: Filter<TSchema>,
+    options: FindOptions,
+    callback: Callback<WithId<TSchema> | null>
+  ): void;
 
   // allow an override of the schema.
   findOne<T = TSchema>(): Promise<T | null>;
@@ -695,10 +699,10 @@ export class Collection<TSchema extends Document = Document> {
   ): void;
 
   findOne(
-    filter?: Filter<TSchema> | Callback<TSchema | null>,
-    options?: FindOptions | Callback<TSchema | null>,
-    callback?: Callback<TSchema | null>
-  ): Promise<TSchema | null> | void {
+    filter?: Filter<TSchema> | Callback<WithId<TSchema> | null>,
+    options?: FindOptions | Callback<WithId<TSchema> | null>,
+    callback?: Callback<WithId<TSchema> | null>
+  ): Promise<WithId<TSchema> | null> | void {
     if (callback != null && typeof callback !== 'function') {
       throw new MongoInvalidArgumentError(
         'Third parameter to `findOne()` must be a callback or undefined'
@@ -706,7 +710,7 @@ export class Collection<TSchema extends Document = Document> {
     }
 
     if (typeof filter === 'function') {
-      callback = filter as Callback<TSchema | null>;
+      callback = filter as Callback<WithId<TSchema> | null>;
       filter = {};
       options = {};
     }
@@ -725,10 +729,10 @@ export class Collection<TSchema extends Document = Document> {
    *
    * @param filter - The filter predicate. If unspecified, then all documents in the collection will match the predicate
    */
-  find(): FindCursor<TSchema>;
-  find(filter: Filter<TSchema>, options?: FindOptions): FindCursor<TSchema>;
-  find<T>(filter: Filter<TSchema>, options?: FindOptions): FindCursor<T>;
-  find(filter?: Filter<TSchema>, options?: FindOptions): FindCursor<TSchema> {
+  find(): FindCursor<WithId<TSchema>>;
+  find(filter: Filter<WithId<TSchema>>, options?: FindOptions): FindCursor<WithId<TSchema>>;
+  find<T>(filter: Filter<WithId<TSchema>>, options?: FindOptions): FindCursor<T>;
+  find(filter?: Filter<WithId<TSchema>>, options?: FindOptions): FindCursor<WithId<TSchema>> {
     if (arguments.length > 2) {
       throw new MongoInvalidArgumentError(
         'Method "collection.find()" accepts at most two arguments'
@@ -738,7 +742,7 @@ export class Collection<TSchema extends Document = Document> {
       throw new MongoInvalidArgumentError('Argument "options" must not be function');
     }
 
-    return new FindCursor<TSchema>(
+    return new FindCursor<WithId<TSchema>>(
       getTopology(this),
       this.s.namespace,
       filter,
@@ -1190,14 +1194,14 @@ export class Collection<TSchema extends Document = Document> {
    * @param options - Optional settings for the command
    * @param callback - An optional callback, a Promise will be returned if none is provided
    */
-  indexes(): Promise<Document>;
-  indexes(callback: Callback<Document>): void;
-  indexes(options: IndexInformationOptions): Promise<Document>;
-  indexes(options: IndexInformationOptions, callback: Callback<Document>): void;
+  indexes(): Promise<Document[]>;
+  indexes(callback: Callback<Document[]>): void;
+  indexes(options: IndexInformationOptions): Promise<Document[]>;
+  indexes(options: IndexInformationOptions, callback: Callback<Document[]>): void;
   indexes(
-    options?: IndexInformationOptions | Callback<Document>,
-    callback?: Callback<Document>
-  ): Promise<Document> | void {
+    options?: IndexInformationOptions | Callback<Document[]>,
+    callback?: Callback<Document[]>
+  ): Promise<Document[]> | void {
     if (typeof options === 'function') (callback = options), (options = {});
 
     return executeOperation(
@@ -1366,7 +1370,7 @@ export class Collection<TSchema extends Document = Document> {
    * @param pipeline - An array of aggregation pipelines to execute
    * @param options - Optional settings for the command
    */
-  aggregate<T = TSchema>(
+  aggregate<T = Document>(
     pipeline: Document[] = [],
     options?: AggregateOptions
   ): AggregationCursor<T> {
@@ -1415,6 +1419,7 @@ export class Collection<TSchema extends Document = Document> {
   /**
    * Run Map Reduce across a collection. Be aware that the inline option for out will return an array of results not a collection.
    *
+   * @deprecated collection.mapReduce is deprecated. Use the aggregation pipeline instead. Visit https://docs.mongodb.com/manual/reference/map-reduce-to-aggregation-pipeline for more information on how to translate map-reduce operations to the aggregation pipeline.
    * @param map - The mapping function.
    * @param reduce - The reduce function.
    * @param options - Optional settings for the command
@@ -1446,6 +1451,9 @@ export class Collection<TSchema extends Document = Document> {
     options?: MapReduceOptions<TKey, TValue> | Callback<Document | Document[]>,
     callback?: Callback<Document | Document[]>
   ): Promise<Document | Document[]> | void {
+    emitWarningOnce(
+      'collection.mapReduce is deprecated. Use the aggregation pipeline instead. Visit https://docs.mongodb.com/manual/reference/map-reduce-to-aggregation-pipeline for more information on how to translate map-reduce operations to the aggregation pipeline.'
+    );
     if ('function' === typeof options) (callback = options), (options = {});
     // Out must always be defined (make sure we don't break weirdly on pre 1.8+ servers)
     // TODO NODE-3339: Figure out if this is still necessary given we no longer officially support pre-1.8