mongodb 4.2.1 → 4.4.0

package/src/cmap/connection.ts

@@ -1,49 +1,59 @@
-import { MessageStream, OperationDescription } from './message_stream';
-import { StreamDescription, StreamDescriptionOptions } from './stream_description';
-import {
-  CommandStartedEvent,
-  CommandFailedEvent,
-  CommandSucceededEvent
-} from './command_monitoring_events';
-import { applySession, ClientSession, updateSessionFromResponse } from '../sessions';
+import { BSONSerializeOptions, Document, Long, ObjectId, pluckBSONSerializeOptions } from '../bson';
 import {
-  uuidV4,
-  ClientMetadata,
-  now,
-  calculateDurationInMs,
-  Callback,
-  MongoDBNamespace,
-  maxWireVersion,
-  HostAddress
-} from '../utils';
+  CLOSE,
+  CLUSTER_TIME_RECEIVED,
+  COMMAND_FAILED,
+  COMMAND_STARTED,
+  COMMAND_SUCCEEDED,
+  MESSAGE,
+  PINNED,
+  UNPINNED
+} from '../constants';
+import type { AutoEncrypter } from '../deps';
 import {
-  MongoRuntimeError,
-  MongoMissingDependencyError,
   MongoCompatibilityError,
+  MongoMissingDependencyError,
   MongoNetworkError,
   MongoNetworkTimeoutError,
+  MongoRuntimeError,
   MongoServerError,
   MongoWriteConcernError
 } from '../error';
+import type { ServerApi, SupportedNodeConnectionOptions } from '../mongo_client';
+import { CancellationToken, TypedEventEmitter } from '../mongo_types';
+import { ReadPreference, ReadPreferenceLike } from '../read_preference';
+import { applySession, ClientSession, updateSessionFromResponse } from '../sessions';
+import {
+  calculateDurationInMs,
+  Callback,
+  ClientMetadata,
+  HostAddress,
+  maxWireVersion,
+  MongoDBNamespace,
+  now,
+  uuidV4
+} from '../utils';
+import type { W, WriteConcern, WriteConcernOptions } from '../write_concern';
+import type { MongoCredentials } from './auth/mongo_credentials';
+import {
+  CommandFailedEvent,
+  CommandStartedEvent,
+  CommandSucceededEvent
+} from './command_monitoring_events';
 import {
   BinMsg,
-  WriteProtocolMessageType,
-  Response,
-  KillCursor,
   GetMore,
-  Query,
+  KillCursor,
+  Msg,
   OpQueryOptions,
-  Msg
+  Query,
+  Response,
+  WriteProtocolMessageType
 } from './commands';
-import { BSONSerializeOptions, Document, Long, pluckBSONSerializeOptions, ObjectId } from '../bson';
-import type { AutoEncrypter } from '../deps';
-import type { MongoCredentials } from './auth/mongo_credentials';
 import type { Stream } from './connect';
+import { MessageStream, OperationDescription } from './message_stream';
+import { StreamDescription, StreamDescriptionOptions } from './stream_description';
 import { applyCommonQueryOptions, getReadPreference, isSharded } from './wire_protocol/shared';
-import { ReadPreference, ReadPreferenceLike } from '../read_preference';
-import type { W, WriteConcern, WriteConcernOptions } from '../write_concern';
-import type { ServerApi, SupportedNodeConnectionOptions } from '../mongo_client';
-import { CancellationToken, TypedEventEmitter } from '../mongo_types';
 
 /** @internal */
 const kStream = Symbol('stream');
@@ -60,7 +70,7 @@ const kClusterTime = Symbol('clusterTime');
 /** @internal */
 const kDescription = Symbol('description');
 /** @internal */
-const kIsMaster = Symbol('ismaster');
+const kHello = Symbol('hello');
 /** @internal */
 const kAutoEncrypter = Symbol('autoEncrypter');
 /** @internal */
@@ -86,7 +96,7 @@ export interface QueryOptions extends BSONSerializeOptions {
 /** @internal */
 export interface CommandOptions extends BSONSerializeOptions {
   command?: boolean;
-  slaveOk?: boolean;
+  secondaryOk?: boolean;
   /** Specify read preference if command supports it */
   readPreference?: ReadPreferenceLike;
   raw?: boolean;
@@ -114,10 +124,19 @@ export interface GetMoreOptions extends CommandOptions {
   comment?: Document | string;
 }
 
+/** @public */
+export interface ProxyOptions {
+  proxyHost?: string;
+  proxyPort?: number;
+  proxyUsername?: string;
+  proxyPassword?: string;
+}
+
 /** @public */
 export interface ConnectionOptions
   extends SupportedNodeConnectionOptions,
-    StreamDescriptionOptions {
+    StreamDescriptionOptions,
+    ProxyOptions {
   // Internal creation info
   id: number | '<monitor>';
   generation: number;
@@ -166,7 +185,7 @@ export class Connection extends TypedEventEmitter<ConnectionEvents> {
   monitorCommands: boolean;
   closed: boolean;
   destroyed: boolean;
-  lastIsMasterMS?: number;
+  lastHelloMS?: number;
   serverApi?: ServerApi;
   helloOk?: boolean;
   /** @internal */
@@ -182,31 +201,31 @@ export class Connection extends TypedEventEmitter<ConnectionEvents> {
   /** @internal */
   [kStream]: Stream;
   /** @internal */
-  [kIsMaster]: Document;
+  [kHello]: Document;
   /** @internal */
   [kClusterTime]: Document;
 
   /** @event */
-  static readonly COMMAND_STARTED = 'commandStarted' as const;
+  static readonly COMMAND_STARTED = COMMAND_STARTED;
   /** @event */
-  static readonly COMMAND_SUCCEEDED = 'commandSucceeded' as const;
+  static readonly COMMAND_SUCCEEDED = COMMAND_SUCCEEDED;
   /** @event */
-  static readonly COMMAND_FAILED = 'commandFailed' as const;
+  static readonly COMMAND_FAILED = COMMAND_FAILED;
   /** @event */
-  static readonly CLUSTER_TIME_RECEIVED = 'clusterTimeReceived' as const;
+  static readonly CLUSTER_TIME_RECEIVED = CLUSTER_TIME_RECEIVED;
   /** @event */
-  static readonly CLOSE = 'close' as const;
+  static readonly CLOSE = CLOSE;
   /** @event */
-  static readonly MESSAGE = 'message' as const;
+  static readonly MESSAGE = MESSAGE;
   /** @event */
-  static readonly PINNED = 'pinned' as const;
+  static readonly PINNED = PINNED;
   /** @event */
-  static readonly UNPINNED = 'unpinned' as const;
+  static readonly UNPINNED = UNPINNED;
 
   constructor(stream: Stream, options: ConnectionOptions) {
     super();
     this.id = options.id;
-    this.address = streamIdentifier(stream);
+    this.address = streamIdentifier(stream, options);
     this.socketTimeoutMS = options.socketTimeoutMS ?? 0;
     this.monitorCommands = options.monitorCommands;
     this.serverApi = options.serverApi;
@@ -221,7 +240,7 @@ export class Connection extends TypedEventEmitter<ConnectionEvents> {
     this[kQueue] = new Map();
     this[kMessageStream] = new MessageStream({
       ...options,
-      maxBsonMessageSize: this.ismaster?.maxBsonMessageSize
+      maxBsonMessageSize: this.hello?.maxBsonMessageSize
     });
     this[kMessageStream].on('message', messageHandler(this));
     this[kStream] = stream;
@@ -242,21 +261,21 @@ export class Connection extends TypedEventEmitter<ConnectionEvents> {
     return this[kDescription];
   }
 
-  get ismaster(): Document {
-    return this[kIsMaster];
+  get hello(): Document {
+    return this[kHello];
   }
 
-  // the `connect` method stores the result of the handshake ismaster on the connection
-  set ismaster(response: Document) {
+  // the `connect` method stores the result of the handshake hello on the connection
+  set hello(response: Document) {
     this[kDescription].receiveResponse(response);
     this[kDescription] = Object.freeze(this[kDescription]);
 
     // TODO: remove this, and only use the `StreamDescription` in the future
-    this[kIsMaster] = response;
+    this[kHello] = response;
   }
 
   get serviceId(): ObjectId | undefined {
-    return this.ismaster?.serviceId;
+    return this.hello?.serviceId;
   }
 
   get loadBalanced(): boolean {
@@ -302,7 +321,7 @@ export class Connection extends TypedEventEmitter<ConnectionEvents> {
       if (issue.isTimeout) {
         op.cb(
           new MongoNetworkTimeoutError(`connection ${this.id} to ${this.address} timed out`, {
-            beforeHandshake: this.ismaster == null
+            beforeHandshake: this.hello == null
           })
         );
       } else if (issue.isClose) {
@@ -417,7 +436,7 @@ export class Connection extends TypedEventEmitter<ConnectionEvents> {
         numberToReturn: -1,
         checkKeys: false,
         // This value is not overridable
-        slaveOk: readPreference.slaveOk()
+        secondaryOk: readPreference.secondaryOk()
       },
       options
     );
@@ -462,7 +481,7 @@ export class Connection extends TypedEventEmitter<ConnectionEvents> {
       numberToReturn,
       pre32Limit: typeof limit === 'number' ? limit : undefined,
       checkKeys: false,
-      slaveOk: readPreference.slaveOk()
+      secondaryOk: readPreference.secondaryOk()
     };
 
     if (options.projection) {
@@ -616,13 +635,6 @@ export class Connection extends TypedEventEmitter<ConnectionEvents> {
   }
 }
 
-/** @public */
-export const APM_EVENTS = [
-  Connection.COMMAND_STARTED,
-  Connection.COMMAND_SUCCEEDED,
-  Connection.COMMAND_FAILED
-];
-
 /** @internal */
 export class CryptoConnection extends Connection {
   /** @internal */
@@ -754,7 +766,13 @@ function messageHandler(conn: Connection) {
   };
 }
 
-function streamIdentifier(stream: Stream) {
+function streamIdentifier(stream: Stream, options: ConnectionOptions): string {
+  if (options.proxyHost) {
+    // If proxy options are specified, the properties of `stream` itself
+    // will not accurately reflect what endpoint this is connected to.
+    return options.hostAddress.toString();
+  }
+
   if (typeof stream.address === 'function') {
     return `${stream.remoteAddress}:${stream.remotePort}`;
   }
@@ -787,6 +805,8 @@ function write(
     promoteValues: typeof options.promoteValues === 'boolean' ? options.promoteValues : true,
     promoteBuffers: typeof options.promoteBuffers === 'boolean' ? options.promoteBuffers : false,
     bsonRegExp: typeof options.bsonRegExp === 'boolean' ? options.bsonRegExp : false,
+    enableUtf8Validation:
+      typeof options.enableUtf8Validation === 'boolean' ? options.enableUtf8Validation : true,
     raw: typeof options.raw === 'boolean' ? options.raw : false,
     started: 0
   };

package/src/cmap/connection_pool.ts

@@ -1,25 +1,38 @@
 import Denque = require('denque');
-import { APM_EVENTS, Connection, ConnectionEvents, ConnectionOptions } from './connection';
-import type { ObjectId } from 'bson';
+import type { ObjectId } from '../bson';
+import {
+  APM_EVENTS,
+  CONNECTION_CHECK_OUT_FAILED,
+  CONNECTION_CHECK_OUT_STARTED,
+  CONNECTION_CHECKED_IN,
+  CONNECTION_CHECKED_OUT,
+  CONNECTION_CLOSED,
+  CONNECTION_CREATED,
+  CONNECTION_POOL_CLEARED,
+  CONNECTION_POOL_CLOSED,
+  CONNECTION_POOL_CREATED,
+  CONNECTION_READY
+} from '../constants';
+import { MongoError, MongoInvalidArgumentError, MongoRuntimeError } from '../error';
 import { Logger } from '../logger';
-import { ConnectionPoolMetrics } from './metrics';
+import { CancellationToken, TypedEventEmitter } from '../mongo_types';
+import { Callback, eachAsync, makeCounter } from '../utils';
 import { connect } from './connect';
-import { eachAsync, makeCounter, Callback } from '../utils';
-import { MongoError, MongoInvalidArgumentError, MongoRuntimeError } from '../error';
-import { PoolClosedError, WaitQueueTimeoutError } from './errors';
+import { Connection, ConnectionEvents, ConnectionOptions } from './connection';
 import {
-  ConnectionPoolCreatedEvent,
-  ConnectionPoolClosedEvent,
-  ConnectionCreatedEvent,
-  ConnectionReadyEvent,
-  ConnectionClosedEvent,
-  ConnectionCheckOutStartedEvent,
-  ConnectionCheckOutFailedEvent,
-  ConnectionCheckedOutEvent,
   ConnectionCheckedInEvent,
-  ConnectionPoolClearedEvent
+  ConnectionCheckedOutEvent,
+  ConnectionCheckOutFailedEvent,
+  ConnectionCheckOutStartedEvent,
+  ConnectionClosedEvent,
+  ConnectionCreatedEvent,
+  ConnectionPoolClearedEvent,
+  ConnectionPoolClosedEvent,
+  ConnectionPoolCreatedEvent,
+  ConnectionReadyEvent
 } from './connection_pool_events';
-import { CancellationToken, TypedEventEmitter } from '../mongo_types';
+import { PoolClosedError, WaitQueueTimeoutError } from './errors';
+import { ConnectionPoolMetrics } from './metrics';
 
 /** @internal */
 const kLogger = Symbol('logger');
@@ -132,52 +145,52 @@ export class ConnectionPool extends TypedEventEmitter<ConnectionPoolEvents> {
    * Emitted when the connection pool is created.
    * @event
    */
-  static readonly CONNECTION_POOL_CREATED = 'connectionPoolCreated' as const;
+  static readonly CONNECTION_POOL_CREATED = CONNECTION_POOL_CREATED;
   /**
    * Emitted once when the connection pool is closed
    * @event
    */
-  static readonly CONNECTION_POOL_CLOSED = 'connectionPoolClosed' as const;
+  static readonly CONNECTION_POOL_CLOSED = CONNECTION_POOL_CLOSED;
   /**
    * Emitted each time the connection pool is cleared and it's generation incremented
    * @event
    */
-  static readonly CONNECTION_POOL_CLEARED = 'connectionPoolCleared' as const;
+  static readonly CONNECTION_POOL_CLEARED = CONNECTION_POOL_CLEARED;
   /**
    * Emitted when a connection is created.
    * @event
    */
-  static readonly CONNECTION_CREATED = 'connectionCreated' as const;
+  static readonly CONNECTION_CREATED = CONNECTION_CREATED;
   /**
    * Emitted when a connection becomes established, and is ready to use
    * @event
    */
-  static readonly CONNECTION_READY = 'connectionReady' as const;
+  static readonly CONNECTION_READY = CONNECTION_READY;
   /**
    * Emitted when a connection is closed
    * @event
    */
-  static readonly CONNECTION_CLOSED = 'connectionClosed' as const;
+  static readonly CONNECTION_CLOSED = CONNECTION_CLOSED;
   /**
    * Emitted when an attempt to check out a connection begins
    * @event
    */
-  static readonly CONNECTION_CHECK_OUT_STARTED = 'connectionCheckOutStarted' as const;
+  static readonly CONNECTION_CHECK_OUT_STARTED = CONNECTION_CHECK_OUT_STARTED;
   /**
    * Emitted when an attempt to check out a connection fails
    * @event
    */
-  static readonly CONNECTION_CHECK_OUT_FAILED = 'connectionCheckOutFailed' as const;
+  static readonly CONNECTION_CHECK_OUT_FAILED = CONNECTION_CHECK_OUT_FAILED;
   /**
    * Emitted each time a connection is successfully checked out of the connection pool
    * @event
    */
-  static readonly CONNECTION_CHECKED_OUT = 'connectionCheckedOut' as const;
+  static readonly CONNECTION_CHECKED_OUT = CONNECTION_CHECKED_OUT;
   /**
    * Emitted each time a connection is successfully checked into the connection pool
    * @event
    */
-  static readonly CONNECTION_CHECKED_IN = 'connectionCheckedIn' as const;
+  static readonly CONNECTION_CHECKED_IN = CONNECTION_CHECKED_IN;
 
   /** @internal */
   constructor(options: ConnectionPoolOptions) {
@@ -664,19 +677,6 @@ function processWaitQueue(pool: ConnectionPool) {
   }
 }
 
-export const CMAP_EVENTS = [
-  ConnectionPool.CONNECTION_POOL_CREATED,
-  ConnectionPool.CONNECTION_POOL_CLOSED,
-  ConnectionPool.CONNECTION_CREATED,
-  ConnectionPool.CONNECTION_READY,
-  ConnectionPool.CONNECTION_CLOSED,
-  ConnectionPool.CONNECTION_CHECK_OUT_STARTED,
-  ConnectionPool.CONNECTION_CHECK_OUT_FAILED,
-  ConnectionPool.CONNECTION_CHECKED_OUT,
-  ConnectionPool.CONNECTION_CHECKED_IN,
-  ConnectionPool.CONNECTION_POOL_CLEARED
-] as const;
-
 /**
  * A callback provided to `withConnection`
  * @internal

package/src/cmap/connection_pool_events.ts

@@ -1,7 +1,7 @@
 import type { ObjectId } from '../bson';
+import type { AnyError } from '../error';
 import type { Connection } from './connection';
 import type { ConnectionPool, ConnectionPoolOptions } from './connection_pool';
-import type { AnyError } from '../error';
 
 /**
  * The base export class for all monitoring events published from the connection pool

package/src/cmap/message_stream.ts

@@ -1,17 +1,18 @@
 import { Duplex, DuplexOptions } from 'stream';
-import { Response, Msg, BinMsg, Query, WriteProtocolMessageType, MessageHeader } from './commands';
+
+import type { BSONSerializeOptions, Document } from '../bson';
 import { MongoDecompressionError, MongoParseError } from '../error';
-import { OP_COMPRESSED, OP_MSG } from './wire_protocol/constants';
+import type { ClientSession } from '../sessions';
+import { BufferPool, Callback } from '../utils';
+import { BinMsg, MessageHeader, Msg, Query, Response, WriteProtocolMessageType } from './commands';
 import {
   compress,
-  decompress,
-  uncompressibleCommands,
   Compressor,
-  CompressorName
+  CompressorName,
+  decompress,
+  uncompressibleCommands
 } from './wire_protocol/compression';
-import type { Document, BSONSerializeOptions } from '../bson';
-import { BufferPool, Callback } from '../utils';
-import type { ClientSession } from '../sessions';
+import { OP_COMPRESSED, OP_MSG } from './wire_protocol/constants';
 
 const MESSAGE_HEADER_SIZE = 16;
 const COMPRESSION_DETAILS_SIZE = 9; // originalOpcode + uncompressedSize, compressorID

package/src/cmap/stream_description.ts

@@ -1,7 +1,7 @@
-import { parseServerType } from '../sdam/server_description';
 import type { Document } from '../bson';
-import type { CompressorName } from './wire_protocol/compression';
 import { ServerType } from '../sdam/common';
+import { parseServerType } from '../sdam/server_description';
+import type { CompressorName } from './wire_protocol/compression';
 
 const RESPONSE_FIELDS = [
   'minWireVersion',
@@ -55,8 +55,8 @@ export class StreamDescription {
 
   receiveResponse(response: Document): void {
     this.type = parseServerType(response);
-    RESPONSE_FIELDS.forEach(field => {
-      if (typeof response[field] != null) {
+    for (const field of RESPONSE_FIELDS) {
+      if (response[field] != null) {
         this[field] = response[field];
       }
 
@@ -64,7 +64,7 @@ export class StreamDescription {
       if ('__nodejs_mock_server__' in response) {
         this.__nodejs_mock_server__ = response['__nodejs_mock_server__'];
       }
-    });
+    }
 
     if (response.compression) {
       this.compressor = this.compressors.filter(c => response.compression?.includes(c))[0];

package/src/cmap/wire_protocol/compression.ts

@@ -1,9 +1,10 @@
 import * as zlib from 'zlib';
-import type { Callback } from '../../utils';
-import type { OperationDescription } from '../message_stream';
 
+import { LEGACY_HELLO_COMMAND } from '../../constants';
 import { PKG_VERSION, Snappy } from '../../deps';
 import { MongoDecompressionError, MongoInvalidArgumentError } from '../../error';
+import type { Callback } from '../../utils';
+import type { OperationDescription } from '../message_stream';
 
 /** @public */
 export const Compressor = Object.freeze({
@@ -19,7 +20,7 @@ export type Compressor = typeof Compressor[CompressorName];
 export type CompressorName = keyof typeof Compressor;
 
 export const uncompressibleCommands = new Set([
-  'ismaster',
+  LEGACY_HELLO_COMMAND,
   'saslStart',
   'saslContinue',
   'getnonce',

package/src/cmap/wire_protocol/shared.ts

@@ -1,15 +1,14 @@
-import { ServerType } from '../../sdam/common';
-import { TopologyDescription } from '../../sdam/topology_description';
+import type { Document } from '../../bson';
 import { MongoInvalidArgumentError } from '../../error';
+import type { ReadPreferenceLike } from '../../read_preference';
 import { ReadPreference } from '../../read_preference';
-import type { Document } from '../../bson';
-import type { OpQueryOptions } from '../commands';
-import type { Topology } from '../../sdam/topology';
+import { ServerType } from '../../sdam/common';
 import type { Server } from '../../sdam/server';
 import type { ServerDescription } from '../../sdam/server_description';
-import type { ReadPreferenceLike } from '../../read_preference';
-import type { CommandOptions } from '../connection';
-import type { Connection } from '../connection';
+import type { Topology } from '../../sdam/topology';
+import { TopologyDescription } from '../../sdam/topology_description';
+import type { OpQueryOptions } from '../commands';
+import type { CommandOptions, Connection } from '../connection';
 
 export interface ReadPreferenceOption {
   readPreference?: ReadPreferenceLike;
@@ -45,7 +44,9 @@ export function applyCommonQueryOptions(
     promoteLongs: typeof options.promoteLongs === 'boolean' ? options.promoteLongs : true,
     promoteValues: typeof options.promoteValues === 'boolean' ? options.promoteValues : true,
     promoteBuffers: typeof options.promoteBuffers === 'boolean' ? options.promoteBuffers : false,
-    bsonRegExp: typeof options.bsonRegExp === 'boolean' ? options.bsonRegExp : false
+    bsonRegExp: typeof options.bsonRegExp === 'boolean' ? options.bsonRegExp : false,
+    enableUtf8Validation:
+      typeof options.enableUtf8Validation === 'boolean' ? options.enableUtf8Validation : true
   });
 
   if (options.session) {