mongodb 4.1.4 → 4.3.0

package/src/cmap/commands.ts

@@ -1,18 +1,18 @@
-import { ReadPreference } from '../read_preference';
+import type { BSONSerializeOptions, Document, Long } from '../bson';
 import * as BSON from '../bson';
-import { databaseNamespace } from '../utils';
-import { OP_QUERY, OP_GETMORE, OP_KILL_CURSORS, OP_MSG } from './wire_protocol/constants';
-import type { Long, Document, BSONSerializeOptions } from '../bson';
+import { MongoInvalidArgumentError, MongoRuntimeError } from '../error';
+import { ReadPreference } from '../read_preference';
 import type { ClientSession } from '../sessions';
+import { databaseNamespace } from '../utils';
 import type { CommandOptions } from './connection';
-import { MongoRuntimeError, MongoInvalidArgumentError } from '../error';
+import { OP_GETMORE, OP_KILL_CURSORS, OP_MSG, OP_QUERY } from './wire_protocol/constants';
 
 // Incrementing request id
 let _requestId = 0;
 
 // Query flags
 const OPTS_TAILABLE_CURSOR = 2;
-const OPTS_SLAVE = 4;
+const OPTS_SECONDARY = 4;
 const OPTS_OPLOG_REPLAY = 8;
 const OPTS_NO_CURSOR_TIMEOUT = 16;
 const OPTS_AWAIT_DATA = 32;
@@ -41,7 +41,7 @@ export interface OpQueryOptions extends CommandOptions {
   ignoreUndefined?: boolean;
   maxBsonSize?: number;
   checkKeys?: boolean;
-  slaveOk?: boolean;
+  secondaryOk?: boolean;
 
   requestId?: number;
   moreToCome?: boolean;
@@ -67,7 +67,7 @@ export class Query {
   checkKeys: boolean;
   batchSize: number;
   tailable: boolean;
-  slaveOk: boolean;
+  secondaryOk: boolean;
   oplogReplay: boolean;
   noCursorTimeout: boolean;
   awaitData: boolean;
@@ -112,7 +112,7 @@ export class Query {
 
     // Flags
     this.tailable = false;
-    this.slaveOk = typeof options.slaveOk === 'boolean' ? options.slaveOk : false;
+    this.secondaryOk = typeof options.secondaryOk === 'boolean' ? options.secondaryOk : false;
     this.oplogReplay = false;
     this.noCursorTimeout = false;
     this.awaitData = false;
@@ -146,8 +146,8 @@ export class Query {
       flags |= OPTS_TAILABLE_CURSOR;
     }
 
-    if (this.slaveOk) {
-      flags |= OPTS_SLAVE;
+    if (this.secondaryOk) {
+      flags |= OPTS_SECONDARY;
     }
 
     if (this.oplogReplay) {
@@ -837,22 +837,24 @@ export class BinMsg {
     const promoteValues = options.promoteValues ?? this.opts.promoteValues;
     const promoteBuffers = options.promoteBuffers ?? this.opts.promoteBuffers;
     const bsonRegExp = options.bsonRegExp ?? this.opts.bsonRegExp;
+    const validation = this.parseBsonSerializationOptions(options);
 
     // Set up the options
-    const _options: BSONSerializeOptions = {
+    const bsonOptions: BSONSerializeOptions = {
       promoteLongs,
       promoteValues,
       promoteBuffers,
-      bsonRegExp
-    };
+      bsonRegExp,
+      validation
+      // Due to the strictness of the BSON libraries validation option we need this cast
+    } as BSONSerializeOptions & { validation: { utf8: { writeErrors: boolean } } };
 
     while (this.index < this.data.length) {
       const payloadType = this.data.readUInt8(this.index++);
       if (payloadType === 0) {
         const bsonSize = this.data.readUInt32LE(this.index);
         const bin = this.data.slice(this.index, this.index + bsonSize);
-        this.documents.push(raw ? bin : BSON.deserialize(bin, _options));
-
+        this.documents.push(raw ? bin : BSON.deserialize(bin, bsonOptions));
         this.index += bsonSize;
       } else if (payloadType === 1) {
         // It was decided that no driver makes use of payload type 1
@@ -865,12 +867,21 @@ export class BinMsg {
     if (this.documents.length === 1 && documentsReturnedIn != null && raw) {
       const fieldsAsRaw: Document = {};
       fieldsAsRaw[documentsReturnedIn] = true;
-      _options.fieldsAsRaw = fieldsAsRaw;
-
-      const doc = BSON.deserialize(this.documents[0] as Buffer, _options);
+      bsonOptions.fieldsAsRaw = fieldsAsRaw;
+      const doc = BSON.deserialize(this.documents[0] as Buffer, bsonOptions);
       this.documents = [doc];
     }
 
     this.parsed = true;
   }
+
+  parseBsonSerializationOptions({ enableUtf8Validation }: BSONSerializeOptions): {
+    utf8: { writeErrors: false } | false;
+  } {
+    if (enableUtf8Validation === false) {
+      return { utf8: false };
+    }
+
+    return { utf8: { writeErrors: false } };
+  }
 }

package/src/cmap/connect.ts

@@ -1,29 +1,53 @@
+import type { Socket, SocketConnectOpts } from 'net';
 import * as net from 'net';
+import { SocksClient } from 'socks';
+import type { ConnectionOptions as TLSConnectionOpts, TLSSocket } from 'tls';
 import * as tls from 'tls';
-import { Connection, ConnectionOptions, CryptoConnection } from './connection';
+
+import type { Document } from '../bson';
+import { Int32 } from '../bson';
 import {
-  MongoNetworkError,
-  MongoNetworkTimeoutError,
   AnyError,
   MongoCompatibilityError,
   MongoInvalidArgumentError,
-  MongoServerError,
-  MongoRuntimeError
+  MongoNetworkError,
+  MongoNetworkTimeoutError,
+  MongoRuntimeError,
+  MongoServerError
 } from '../error';
-import { AUTH_PROVIDERS, AuthMechanism } from './auth/defaultAuthProviders';
-import { AuthContext } from './auth/auth_provider';
-import { makeClientMetadata, ClientMetadata, Callback, CallbackWithType, ns } from '../utils';
 import {
-  MAX_SUPPORTED_WIRE_VERSION,
+  Callback,
+  CallbackWithType,
+  ClientMetadata,
+  HostAddress,
+  makeClientMetadata,
+  ns
+} from '../utils';
+import { AuthContext, AuthProvider } from './auth/auth_provider';
+import { GSSAPI } from './auth/gssapi';
+import { MongoCR } from './auth/mongocr';
+import { MongoDBAWS } from './auth/mongodb_aws';
+import { Plain } from './auth/plain';
+import { AuthMechanism } from './auth/providers';
+import { ScramSHA1, ScramSHA256 } from './auth/scram';
+import { X509 } from './auth/x509';
+import { Connection, ConnectionOptions, CryptoConnection } from './connection';
+import {
   MAX_SUPPORTED_SERVER_VERSION,
-  MIN_SUPPORTED_WIRE_VERSION,
-  MIN_SUPPORTED_SERVER_VERSION
+  MAX_SUPPORTED_WIRE_VERSION,
+  MIN_SUPPORTED_SERVER_VERSION,
+  MIN_SUPPORTED_WIRE_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';
+const AUTH_PROVIDERS = new Map<AuthMechanism | string, AuthProvider>([
+  [AuthMechanism.MONGODB_AWS, new MongoDBAWS()],
+  [AuthMechanism.MONGODB_CR, new MongoCR()],
+  [AuthMechanism.MONGODB_GSSAPI, new GSSAPI()],
+  [AuthMechanism.MONGODB_PLAIN, new Plain()],
+  [AuthMechanism.MONGODB_SCRAM_SHA1, new ScramSHA1()],
+  [AuthMechanism.MONGODB_SCRAM_SHA256, new ScramSHA256()],
+  [AuthMechanism.MONGODB_X509, new X509()]
+]);
 
 const FAKE_MONGODB_SERVICE_ID =
   typeof process.env.FAKE_MONGODB_SERVICE_ID === 'string' &&
@@ -33,7 +57,7 @@ const FAKE_MONGODB_SERVICE_ID =
 export type Stream = Socket | TLSSocket;
 
 export function connect(options: ConnectionOptions, callback: Callback<Connection>): void {
-  makeConnection(options, (err, socket) => {
+  makeConnection({ ...options, existingSocket: undefined }, (err, socket) => {
     if (err || !socket) {
       return callback(err);
     }
@@ -289,7 +313,9 @@ function parseConnectOptions(options: ConnectionOptions): SocketConnectOpts {
   }
 }
 
-function parseSslOptions(options: ConnectionOptions): TLSConnectionOpts {
+type MakeConnectionOptions = ConnectionOptions & { existingSocket?: Stream };
+
+function parseSslOptions(options: MakeConnectionOptions): TLSConnectionOpts {
   const result: TLSConnectionOpts = parseConnectOptions(options);
   // Merge in valid SSL options
   for (const name of LEGAL_TLS_SOCKET_OPTIONS) {
@@ -298,6 +324,10 @@ function parseSslOptions(options: ConnectionOptions): TLSConnectionOpts {
     }
   }
 
+  if (options.existingSocket) {
+    result.socket = options.existingSocket;
+  }
+
   // Set default sni servername to be the same as host
   if (result.servername == null && result.host && !net.isIP(result.host)) {
     result.servername = result.host;
@@ -310,17 +340,21 @@ const SOCKET_ERROR_EVENT_LIST = ['error', 'close', 'timeout', 'parseError'] as c
 type ErrorHandlerEventName = typeof SOCKET_ERROR_EVENT_LIST[number] | 'cancel';
 const SOCKET_ERROR_EVENTS = new Set(SOCKET_ERROR_EVENT_LIST);
 
-function makeConnection(options: ConnectionOptions, _callback: CallbackWithType<AnyError, Stream>) {
+function makeConnection(
+  options: MakeConnectionOptions,
+  _callback: CallbackWithType<AnyError, Stream>
+) {
   const useTLS = options.tls ?? false;
   const keepAlive = options.keepAlive ?? true;
   const socketTimeoutMS = options.socketTimeoutMS ?? Reflect.get(options, 'socketTimeout') ?? 0;
   const noDelay = options.noDelay ?? true;
-  const connectionTimeout = options.connectTimeoutMS ?? 30000;
+  const connectTimeoutMS = options.connectTimeoutMS ?? 30000;
   const rejectUnauthorized = options.rejectUnauthorized ?? true;
   const keepAliveInitialDelay =
     ((options.keepAliveInitialDelay ?? 120000) > socketTimeoutMS
       ? Math.round(socketTimeoutMS / 2)
       : options.keepAliveInitialDelay) ?? 120000;
+  const existingSocket = options.existingSocket;
 
   let socket: Stream;
   const callback: Callback<Stream> = function (err, ret) {
@@ -331,18 +365,34 @@ function makeConnection(options: ConnectionOptions, _callback: CallbackWithType<
     _callback(err, ret);
   };
 
+  if (options.proxyHost != null) {
+    // Currently, only Socks5 is supported.
+    return makeSocks5Connection(
+      {
+        ...options,
+        connectTimeoutMS // Should always be present for Socks5
+      },
+      callback
+    );
+  }
+
   if (useTLS) {
     const tlsSocket = tls.connect(parseSslOptions(options));
     if (typeof tlsSocket.disableRenegotiation === 'function') {
       tlsSocket.disableRenegotiation();
     }
     socket = tlsSocket;
+  } else if (existingSocket) {
+    // In the TLS case, parseSslOptions() sets options.socket to existingSocket,
+    // so we only need to handle the non-TLS case here (where existingSocket
+    // gives us all we need out of the box).
+    socket = existingSocket;
   } else {
     socket = net.createConnection(parseConnectOptions(options));
   }
 
   socket.setKeepAlive(keepAlive, keepAliveInitialDelay);
-  socket.setTimeout(connectionTimeout);
+  socket.setTimeout(connectTimeoutMS);
   socket.setNoDelay(noDelay);
 
   const connectEvent = useTLS ? 'secureConnect' : 'connect';
@@ -381,10 +431,80 @@ function makeConnection(options: ConnectionOptions, _callback: CallbackWithType<
     options.cancellationToken.once('cancel', cancellationHandler);
   }
 
-  socket.once(connectEvent, connectHandler);
+  if (existingSocket) {
+    process.nextTick(connectHandler);
+  } else {
+    socket.once(connectEvent, connectHandler);
+  }
+}
+
+function makeSocks5Connection(options: MakeConnectionOptions, callback: Callback<Stream>) {
+  const hostAddress = HostAddress.fromHostPort(
+    options.proxyHost ?? '', // proxyHost is guaranteed to set here
+    options.proxyPort ?? 1080
+  );
+
+  // First, connect to the proxy server itself:
+  makeConnection(
+    {
+      ...options,
+      hostAddress,
+      tls: false,
+      proxyHost: undefined
+    },
+    (err, rawSocket) => {
+      if (err) {
+        return callback(err);
+      }
+
+      const destination = parseConnectOptions(options) as net.TcpNetConnectOpts;
+      if (typeof destination.host !== 'string' || typeof destination.port !== 'number') {
+        return callback(
+          new MongoInvalidArgumentError('Can only make Socks5 connections to TCP hosts')
+        );
+      }
+
+      // Then, establish the Socks5 proxy connection:
+      SocksClient.createConnection(
+        {
+          existing_socket: rawSocket,
+          timeout: options.connectTimeoutMS,
+          command: 'connect',
+          destination: {
+            host: destination.host,
+            port: destination.port
+          },
+          proxy: {
+            // host and port are ignored because we pass existing_socket
+            host: 'iLoveJavaScript',
+            port: 0,
+            type: 5,
+            userId: options.proxyUsername || undefined,
+            password: options.proxyPassword || undefined
+          }
+        },
+        (err: AnyError, info: { socket: Stream }) => {
+          if (err) {
+            return callback(connectionFailureError('error', err));
+          }
+
+          // Finally, now treat the resulting duplex stream as the
+          // socket over which we send and receive wire protocol messages:
+          makeConnection(
+            {
+              ...options,
+              existingSocket: info.socket,
+              proxyHost: undefined
+            },
+            callback
+          );
+        }
+      );
+    }
+  );
 }
 
-function connectionFailureError(type: string, err: Error) {
+function connectionFailureError(type: ErrorHandlerEventName, err: Error) {
   switch (type) {
     case 'error':
       return new MongoNetworkError(err);

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');
@@ -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;
@@ -97,6 +107,7 @@ export interface CommandOptions extends BSONSerializeOptions {
   session?: ClientSession;
   documentsReturnedIn?: string;
   noResponse?: boolean;
+  omitReadPreference?: boolean;
 
   // FIXME: NODE-2802
   willRetryWrite?: boolean;
@@ -113,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;
@@ -186,26 +206,26 @@ export class Connection extends TypedEventEmitter<ConnectionEvents> {
   [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;
@@ -416,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
     );
@@ -461,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) {
@@ -615,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 */
@@ -753,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}`;
   }
@@ -786,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
   };