mongodb 4.2.0 → 4.3.1

package/src/bson.ts

@@ -1,11 +1,14 @@
 import type {
-  serialize as serializeFn,
+  calculateObjectSize as calculateObjectSizeFn,
   deserialize as deserializeFn,
-  calculateObjectSize as calculateObjectSizeFn
+  DeserializeOptions,
+  serialize as serializeFn,
+  SerializeOptions
 } from 'bson';
 
 // eslint-disable-next-line @typescript-eslint/no-var-requires
 let BSON = require('bson');
+
 try {
   // Ensure you always wrap an optional require in the try block NODE-3199
   BSON = require('bson-ext');
@@ -19,25 +22,23 @@ export const serialize = BSON.serialize as typeof serializeFn;
 export const calculateObjectSize = BSON.calculateObjectSize as typeof calculateObjectSizeFn;
 
 export {
-  Long,
   Binary,
-  ObjectId,
-  Timestamp,
+  BSONRegExp,
+  BSONSymbol,
   Code,
-  MinKey,
-  MaxKey,
+  DBRef,
   Decimal128,
-  Int32,
+  Document,
   Double,
-  DBRef,
-  BSONRegExp,
-  BSONSymbol,
+  Int32,
+  Long,
   Map,
-  Document
+  MaxKey,
+  MinKey,
+  ObjectId,
+  Timestamp
 } from 'bson';
 
-import type { DeserializeOptions, SerializeOptions } from 'bson';
-
 /**
  * BSON Serialization options.
  * @public
@@ -51,9 +52,13 @@ export interface BSONSerializeOptions
       | 'cacheFunctionsCrc32'
       | 'allowObjectSmallerThanBufferSize'
       | 'index'
+      | 'validation'
     > {
   /** Return BSON filled buffers from operations */
   raw?: boolean;
+
+  /** Enable utf8 validation when deserializing BSON documents.  Defaults to true. */
+  enableUtf8Validation?: boolean;
 }
 
 export function pluckBSONSerializeOptions(options: BSONSerializeOptions): BSONSerializeOptions {
@@ -65,7 +70,8 @@ export function pluckBSONSerializeOptions(options: BSONSerializeOptions): BSONSe
     serializeFunctions,
     ignoreUndefined,
     bsonRegExp,
-    raw
+    raw,
+    enableUtf8Validation
   } = options;
   return {
     fieldsAsRaw,
@@ -75,7 +81,8 @@ export function pluckBSONSerializeOptions(options: BSONSerializeOptions): BSONSe
     serializeFunctions,
     ignoreUndefined,
     bsonRegExp,
-    raw
+    raw,
+    enableUtf8Validation
   };
 }
 
@@ -98,6 +105,8 @@ export function resolveBSONOptions(
     ignoreUndefined: options?.ignoreUndefined ?? parentOptions?.ignoreUndefined ?? false,
     bsonRegExp: options?.bsonRegExp ?? parentOptions?.bsonRegExp ?? false,
     serializeFunctions: options?.serializeFunctions ?? parentOptions?.serializeFunctions ?? false,
-    fieldsAsRaw: options?.fieldsAsRaw ?? parentOptions?.fieldsAsRaw ?? {}
+    fieldsAsRaw: options?.fieldsAsRaw ?? parentOptions?.fieldsAsRaw ?? {},
+    enableUtf8Validation:
+      options?.enableUtf8Validation ?? parentOptions?.enableUtf8Validation ?? true
   };
 }

package/src/bulk/common.ts

@@ -1,39 +1,39 @@
-import { PromiseProvider } from '../promise_provider';
 import {
+  BSONSerializeOptions,
+  Document,
   Long,
   ObjectId,
-  Document,
-  BSONSerializeOptions,
   resolveBSONOptions,
   Timestamp
 } from '../bson';
+import type { Collection } from '../collection';
 import {
-  MongoWriteConcernError,
   AnyError,
+  MongoBatchReExecutionError,
   MONGODB_ERROR_CODES,
-  MongoServerError,
   MongoInvalidArgumentError,
-  MongoBatchReExecutionError
+  MongoServerError,
+  MongoWriteConcernError
 } from '../error';
+import type { Filter, OneOrMore, OptionalId, UpdateFilter, WithoutId } from '../mongo_types';
+import type { CollationOptions, CommandOperationOptions } from '../operations/command';
+import { DeleteOperation, DeleteStatement, makeDeleteStatement } from '../operations/delete';
+import { executeOperation } from '../operations/execute_operation';
+import { InsertOperation } from '../operations/insert';
+import type { Hint } from '../operations/operation';
+import { makeUpdateStatement, UpdateOperation, UpdateStatement } from '../operations/update';
+import { PromiseProvider } from '../promise_provider';
+import type { Topology } from '../sdam/topology';
 import {
   applyRetryableWrites,
+  Callback,
   executeLegacyOperation,
+  getTopology,
   hasAtomicOperators,
-  Callback,
   MongoDBNamespace,
-  getTopology,
   resolveOptions
 } from '../utils';
-import { executeOperation } from '../operations/execute_operation';
-import { InsertOperation } from '../operations/insert';
-import { UpdateOperation, UpdateStatement, makeUpdateStatement } from '../operations/update';
-import { DeleteOperation, DeleteStatement, makeDeleteStatement } from '../operations/delete';
 import { WriteConcern } from '../write_concern';
-import type { Collection } from '../collection';
-import type { Topology } from '../sdam/topology';
-import type { CommandOperationOptions, CollationOptions } from '../operations/command';
-import type { Hint } from '../operations/operation';
-import type { Filter, OneOrMore, OptionalId, UpdateFilter } from '../mongo_types';
 
 /** @internal */
 const kServerError = Symbol('serverError');
@@ -79,7 +79,7 @@ export interface ReplaceOneModel<TSchema extends Document = Document> {
   /** The filter to limit the replaced document. */
   filter: Filter<TSchema>;
   /** The document with which to replace the matched document. */
-  replacement: TSchema;
+  replacement: WithoutId<TSchema>;
   /** Specifies a collation. */
   collation?: CollationOptions;
   /** The index to use. If specified, then the query system will only consider plans using the hinted index. */
@@ -940,7 +940,7 @@ export abstract class BulkOperationBase {
 
     const topology = getTopology(collection);
     options = options == null ? {} : options;
-    // TODO Bring from driver information in isMaster
+    // TODO Bring from driver information in hello
     // Get the namespace for the write operations
     const namespace = collection.s.namespace;
     // Used to mark operation as executed
@@ -950,16 +950,15 @@ export abstract class BulkOperationBase {
     const currentOp = undefined;
 
     // Set max byte size
-    const isMaster = topology.lastIsMaster();
+    const hello = topology.lastHello();
 
     // If we have autoEncryption on, batch-splitting must be done on 2mb chunks, but single documents
     // over 2mb are still allowed
     const usingAutoEncryption = !!(topology.s.options && topology.s.options.autoEncrypter);
     const maxBsonObjectSize =
-      isMaster && isMaster.maxBsonObjectSize ? isMaster.maxBsonObjectSize : 1024 * 1024 * 16;
+      hello && hello.maxBsonObjectSize ? hello.maxBsonObjectSize : 1024 * 1024 * 16;
     const maxBatchSizeBytes = usingAutoEncryption ? 1024 * 1024 * 2 : maxBsonObjectSize;
-    const maxWriteBatchSize =
-      isMaster && isMaster.maxWriteBatchSize ? isMaster.maxWriteBatchSize : 1000;
+    const maxWriteBatchSize = hello && hello.maxWriteBatchSize ? hello.maxWriteBatchSize : 1000;
 
     // Calculates the largest possible size of an Array key, represented as a BSON string
     // element. This calculation:

package/src/bulk/ordered.ts

@@ -1,10 +1,10 @@
-import * as BSON from '../bson';
-import { BulkOperationBase, Batch, BatchType, BulkWriteOptions } from './common';
 import type { Document } from '../bson';
+import * as BSON from '../bson';
 import type { Collection } from '../collection';
-import type { UpdateStatement } from '../operations/update';
-import type { DeleteStatement } from '../operations/delete';
 import { MongoInvalidArgumentError } from '../error';
+import type { DeleteStatement } from '../operations/delete';
+import type { UpdateStatement } from '../operations/update';
+import { Batch, BatchType, BulkOperationBase, BulkWriteOptions } from './common';
 
 /** @public */
 export class OrderedBulkOperation extends BulkOperationBase {

package/src/bulk/unordered.ts

@@ -1,11 +1,11 @@
-import * as BSON from '../bson';
-import { BulkOperationBase, Batch, BatchType, BulkWriteOptions, BulkWriteResult } from './common';
-import type { Callback } from '../utils';
 import type { Document } from '../bson';
+import * as BSON from '../bson';
 import type { Collection } from '../collection';
-import type { UpdateStatement } from '../operations/update';
-import type { DeleteStatement } from '../operations/delete';
 import { MongoInvalidArgumentError } from '../error';
+import type { DeleteStatement } from '../operations/delete';
+import type { UpdateStatement } from '../operations/update';
+import type { Callback } from '../utils';
+import { Batch, BatchType, BulkOperationBase, BulkWriteOptions, BulkWriteResult } from './common';
 
 /** @public */
 export class UnorderedBulkOperation extends BulkOperationBase {

package/src/change_stream.ts

@@ -1,39 +1,40 @@
 import Denque = require('denque');
+import type { Readable } from 'stream';
+
+import type { Document, Timestamp } from './bson';
+import { Collection } from './collection';
+import {
+  AbstractCursor,
+  AbstractCursorEvents,
+  AbstractCursorOptions,
+  CursorStreamOptions
+} from './cursor/abstract_cursor';
+import { Db } from './db';
 import {
-  MongoError,
   AnyError,
   isResumableError,
-  MongoRuntimeError,
   MongoAPIError,
-  MongoChangeStreamError
+  MongoChangeStreamError,
+  MongoError,
+  MongoRuntimeError
 } from './error';
+import { MongoClient } from './mongo_client';
+import { InferIdType, Nullable, TypedEventEmitter } from './mongo_types';
 import { AggregateOperation, AggregateOptions } from './operations/aggregate';
+import type { CollationOptions, OperationParent } from './operations/command';
+import { executeOperation, ExecutionResult } from './operations/execute_operation';
+import type { ReadPreference } from './read_preference';
+import type { Topology } from './sdam/topology';
+import type { ClientSession } from './sessions';
 import {
-  maxWireVersion,
   calculateDurationInMs,
-  now,
+  Callback,
+  getTopology,
+  maxWireVersion,
   maybePromise,
   MongoDBNamespace,
-  Callback,
-  getTopology
+  now
 } from './utils';
-import type { ReadPreference } from './read_preference';
-import type { Timestamp, Document } from './bson';
-import type { Topology } from './sdam/topology';
-import type { OperationParent, CollationOptions } from './operations/command';
-import { MongoClient } from './mongo_client';
-import { Db } from './db';
-import { Collection } from './collection';
-import type { Readable } from 'stream';
-import {
-  AbstractCursor,
-  AbstractCursorEvents,
-  AbstractCursorOptions,
-  CursorStreamOptions
-} from './cursor/abstract_cursor';
-import type { ClientSession } from './sessions';
-import { executeOperation, ExecutionResult } from './operations/execute_operation';
-import { InferIdType, Nullable, TypedEventEmitter } from './mongo_types';
 
 /** @internal */
 const kResumeQueue = Symbol('resumeQueue');
@@ -70,7 +71,7 @@ export interface ResumeOptions {
 }
 
 /**
- * Represents the logical starting point for a new or resuming {@link https://docs.mongodb.com/master/changeStreams/#change-stream-resume-token| Change Stream} on the server.
+ * Represents the logical starting point for a new or resuming {@link https://docs.mongodb.com/manual/changeStreams/#std-label-change-stream-resume| Change Stream} on the server.
  * @public
  */
 export type ResumeToken = unknown;
@@ -97,9 +98,9 @@ export interface ChangeStreamOptions extends AggregateOptions {
   fullDocument?: string;
   /** The maximum amount of time for the server to wait on new documents to satisfy a change stream query. */
   maxAwaitTimeMS?: number;
-  /** Allows you to start a changeStream after a specified event. See {@link https://docs.mongodb.com/master/changeStreams/#resumeafter-for-change-streams|ChangeStream documentation}. */
+  /** Allows you to start a changeStream after a specified event. See {@link https://docs.mongodb.com/manual/changeStreams/#resumeafter-for-change-streams|ChangeStream documentation}. */
   resumeAfter?: ResumeToken;
-  /** Similar to resumeAfter, but will allow you to start after an invalidated event. See {@link https://docs.mongodb.com/master/changeStreams/#startafter-for-change-streams|ChangeStream documentation}. */
+  /** Similar to resumeAfter, but will allow you to start after an invalidated event. See {@link https://docs.mongodb.com/manual/changeStreams/#startafter-for-change-streams|ChangeStream documentation}. */
   startAfter?: ResumeToken;
   /** Will start the changeStream after the specified operationTime. */
   startAtOperationTime?: OperationTime;
@@ -310,7 +311,9 @@ export class ChangeStream<TSchema extends Document = Document> extends TypedEven
   }
 
   /** Check if there is any document still available in the Change Stream */
-  hasNext(callback?: Callback): Promise<void> | void {
+  hasNext(): Promise<boolean>;
+  hasNext(callback: Callback<boolean>): void;
+  hasNext(callback?: Callback): Promise<boolean> | void {
     setIsIterator(this);
     return maybePromise(callback, cb => {
       getCursor(this, (err, cursor) => {

package/src/cmap/auth/auth_provider.ts

@@ -1,9 +1,9 @@
 import type { Document } from '../../bson';
+import { MongoRuntimeError } from '../../error';
+import type { Callback, ClientMetadataOptions } from '../../utils';
+import type { HandshakeDocument } from '../connect';
 import type { Connection, ConnectionOptions } from '../connection';
 import type { MongoCredentials } from './mongo_credentials';
-import type { HandshakeDocument } from '../connect';
-import type { ClientMetadataOptions, Callback } from '../../utils';
-import { MongoRuntimeError } from '../../error';
 
 export type AuthContextOptions = ConnectionOptions & ClientMetadataOptions;
 

package/src/cmap/auth/gssapi.ts

@@ -1,14 +1,16 @@
-import { AuthProvider, AuthContext } from './auth_provider';
+import * as dns from 'dns';
+
+import type { Document } from '../../bson';
+import { Kerberos, KerberosClient } from '../../deps';
 import {
-  MongoRuntimeError,
+  MongoError,
   MongoInvalidArgumentError,
   MongoMissingCredentialsError,
-  MongoError,
-  MongoMissingDependencyError
+  MongoMissingDependencyError,
+  MongoRuntimeError
 } from '../../error';
-import { Kerberos, KerberosClient } from '../../deps';
 import { Callback, ns } from '../../utils';
-import type { Document } from '../../bson';
+import { AuthContext, AuthProvider } from './auth_provider';
 
 type MechanismProperties = {
   gssapiCanonicalizeHostName?: boolean;
@@ -16,8 +18,6 @@ type MechanismProperties = {
   SERVICE_REALM?: string;
 };
 
-import * as dns from 'dns';
-
 export class GSSAPI extends AuthProvider {
   auth(authContext: AuthContext, callback: Callback): void {
     const { connection, credentials } = authContext;

package/src/cmap/auth/mongo_credentials.ts

@@ -2,21 +2,21 @@
 
 import type { Document } from '../../bson';
 import { MongoAPIError, MongoMissingCredentialsError } from '../../error';
-import { AuthMechanism } from './defaultAuthProviders';
+import { AUTH_MECHS_AUTH_SRC_EXTERNAL, AuthMechanism } from './providers';
 
 // https://github.com/mongodb/specifications/blob/master/source/auth/auth.rst
-function getDefaultAuthMechanism(ismaster?: Document): AuthMechanism {
-  if (ismaster) {
-    // If ismaster contains saslSupportedMechs, use scram-sha-256
+function getDefaultAuthMechanism(hello?: Document): AuthMechanism {
+  if (hello) {
+    // If hello contains saslSupportedMechs, use scram-sha-256
     // if it is available, else scram-sha-1
-    if (Array.isArray(ismaster.saslSupportedMechs)) {
-      return ismaster.saslSupportedMechs.includes(AuthMechanism.MONGODB_SCRAM_SHA256)
+    if (Array.isArray(hello.saslSupportedMechs)) {
+      return hello.saslSupportedMechs.includes(AuthMechanism.MONGODB_SCRAM_SHA256)
         ? AuthMechanism.MONGODB_SCRAM_SHA256
         : AuthMechanism.MONGODB_SCRAM_SHA1;
     }
 
     // Fallback to legacy selection method. If wire version >= 3, use scram-sha-1
-    if (ismaster.maxWireVersion >= 3) {
+    if (hello.maxWireVersion >= 3) {
       return AuthMechanism.MONGODB_SCRAM_SHA1;
     }
   }
@@ -107,16 +107,16 @@ export class MongoCredentials {
    * If the authentication mechanism is set to "default", resolves the authMechanism
    * based on the server version and server supported sasl mechanisms.
    *
-   * @param ismaster - An ismaster response from the server
+   * @param hello - A hello response from the server
    */
-  resolveAuthMechanism(ismaster?: Document): MongoCredentials {
+  resolveAuthMechanism(hello?: Document): MongoCredentials {
     // If the mechanism is not "default", then it does not need to be resolved
     if (this.mechanism.match(/DEFAULT/i)) {
       return new MongoCredentials({
         username: this.username,
         password: this.password,
         source: this.source,
-        mechanism: getDefaultAuthMechanism(ismaster),
+        mechanism: getDefaultAuthMechanism(hello),
         mechanismProperties: this.mechanismProperties
       });
     }
@@ -136,11 +136,7 @@ export class MongoCredentials {
       throw new MongoMissingCredentialsError(`Username required for mechanism '${this.mechanism}'`);
     }
 
-    if (
-      this.mechanism === AuthMechanism.MONGODB_GSSAPI ||
-      this.mechanism === AuthMechanism.MONGODB_AWS ||
-      this.mechanism === AuthMechanism.MONGODB_X509
-    ) {
+    if (AUTH_MECHS_AUTH_SRC_EXTERNAL.has(this.mechanism)) {
       if (this.source != null && this.source !== '$external') {
         // TODO(NODE-3485): Replace this with a MongoAuthValidationError
         throw new MongoAPIError(

package/src/cmap/auth/mongocr.ts

@@ -1,7 +1,8 @@
 import * as crypto from 'crypto';
-import { AuthProvider, AuthContext } from './auth_provider';
-import { Callback, ns } from '../../utils';
+
 import { MongoMissingCredentialsError } from '../../error';
+import { Callback, ns } from '../../utils';
+import { AuthContext, AuthProvider } from './auth_provider';
 
 export class MongoCR extends AuthProvider {
   auth(authContext: AuthContext, callback: Callback): void {

package/src/cmap/auth/mongodb_aws.ts

@@ -1,20 +1,19 @@
-import * as http from 'http';
 import * as crypto from 'crypto';
+import * as http from 'http';
 import * as url from 'url';
+
+import type { Binary, BSONSerializeOptions } from '../../bson';
 import * as BSON from '../../bson';
-import { AuthProvider, AuthContext } from './auth_provider';
-import { MongoCredentials } from './mongo_credentials';
+import { aws4 } from '../../deps';
 import {
-  MongoRuntimeError,
+  MongoCompatibilityError,
   MongoMissingCredentialsError,
-  MongoCompatibilityError
+  MongoRuntimeError
 } 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';
+import { Callback, maxWireVersion, ns } from '../../utils';
+import { AuthContext, AuthProvider } from './auth_provider';
+import { MongoCredentials } from './mongo_credentials';
+import { AuthMechanism } from './providers';
 
 const ASCII_N = 110;
 const AWS_RELATIVE_URI = 'http://169.254.170.2';

package/src/cmap/auth/plain.ts

@@ -1,7 +1,7 @@
 import { Binary } from '../../bson';
-import { AuthProvider, AuthContext } from './auth_provider';
 import { MongoMissingCredentialsError } from '../../error';
 import { Callback, ns } from '../../utils';
+import { AuthContext, AuthProvider } from './auth_provider';
 
 export class Plain extends AuthProvider {
   auth(authContext: AuthContext, callback: Callback): void {

package/src/cmap/auth/providers.ts

@@ -0,0 +1,21 @@
+/** @public */
+export const AuthMechanism = Object.freeze({
+  MONGODB_AWS: 'MONGODB-AWS',
+  MONGODB_CR: 'MONGODB-CR',
+  MONGODB_DEFAULT: 'DEFAULT',
+  MONGODB_GSSAPI: 'GSSAPI',
+  MONGODB_PLAIN: 'PLAIN',
+  MONGODB_SCRAM_SHA1: 'SCRAM-SHA-1',
+  MONGODB_SCRAM_SHA256: 'SCRAM-SHA-256',
+  MONGODB_X509: 'MONGODB-X509'
+} as const);
+
+/** @public */
+export type AuthMechanism = typeof AuthMechanism[keyof typeof AuthMechanism];
+
+/** @internal */
+export const AUTH_MECHS_AUTH_SRC_EXTERNAL = new Set<AuthMechanism>([
+  AuthMechanism.MONGODB_GSSAPI,
+  AuthMechanism.MONGODB_AWS,
+  AuthMechanism.MONGODB_X509
+]);

package/src/cmap/auth/scram.ts

@@ -1,19 +1,19 @@
 import * as crypto from 'crypto';
+
 import { Binary, Document } from '../../bson';
+import { saslprep } from '../../deps';
 import {
   AnyError,
-  MongoRuntimeError,
-  MongoServerError,
   MongoInvalidArgumentError,
-  MongoMissingCredentialsError
+  MongoMissingCredentialsError,
+  MongoRuntimeError,
+  MongoServerError
 } from '../../error';
-import { AuthProvider, AuthContext } from './auth_provider';
-import { Callback, ns, emitWarning } from '../../utils';
-import type { MongoCredentials } from './mongo_credentials';
+import { Callback, emitWarning, ns } from '../../utils';
 import type { HandshakeDocument } from '../connect';
-
-import { saslprep } from '../../deps';
-import { AuthMechanism } from './defaultAuthProviders';
+import { AuthContext, AuthProvider } from './auth_provider';
+import type { MongoCredentials } from './mongo_credentials';
+import { AuthMechanism } from './providers';
 
 type CryptoMethod = 'sha1' | 'sha256';
 

package/src/cmap/auth/x509.ts

@@ -1,9 +1,9 @@
-import { AuthProvider, AuthContext } from './auth_provider';
-import { MongoMissingCredentialsError } from '../../error';
 import type { Document } from '../../bson';
+import { MongoMissingCredentialsError } from '../../error';
 import { Callback, ns } from '../../utils';
-import type { MongoCredentials } from './mongo_credentials';
 import type { HandshakeDocument } from '../connect';
+import { AuthContext, AuthProvider } from './auth_provider';
+import type { MongoCredentials } from './mongo_credentials';
 
 export class X509 extends AuthProvider {
   prepare(handshakeDoc: HandshakeDocument, authContext: AuthContext, callback: Callback): void {

package/src/cmap/command_monitoring_events.ts

@@ -1,7 +1,8 @@
-import { GetMore, KillCursor, Msg, WriteProtocolMessageType } from './commands';
+import type { Document, ObjectId } from '../bson';
+import { LEGACY_HELLO_COMMAND, LEGACY_HELLO_COMMAND_CAMEL_CASE } from '../constants';
 import { calculateDurationInMs, deepCopy } from '../utils';
+import { GetMore, KillCursor, Msg, WriteProtocolMessageType } from './commands';
 import type { Connection } from './connection';
-import type { Document, ObjectId } from '../bson';
 
 /**
  * An event indicating the start of a given
@@ -161,7 +162,7 @@ const SENSITIVE_COMMANDS = new Set([
   'copydb'
 ]);
 
-const HELLO_COMMANDS = new Set(['hello', 'ismaster', 'isMaster']);
+const HELLO_COMMANDS = new Set(['hello', LEGACY_HELLO_COMMAND, LEGACY_HELLO_COMMAND_CAMEL_CASE]);
 
 // helper methods
 const extractCommandName = (commandDoc: Document) => Object.keys(commandDoc)[0];