mongodb 4.1.4 → 4.3.0

package/src/connection_string.ts

@@ -2,22 +2,14 @@ import * as dns from 'dns';
 import * as fs from 'fs';
 import ConnectionString from 'mongodb-connection-string-url';
 import { URLSearchParams } from 'url';
-import { AuthMechanism } from './cmap/auth/defaultAuthProviders';
-import { ReadPreference, ReadPreferenceMode } from './read_preference';
-import { ReadConcern, ReadConcernLevel } from './read_concern';
-import { W, WriteConcern } from './write_concern';
-import { MongoAPIError, MongoInvalidArgumentError, MongoParseError } from './error';
-import {
-  AnyOptions,
-  Callback,
-  DEFAULT_PK_FACTORY,
-  isRecord,
-  makeClientMetadata,
-  setDifference,
-  HostAddress,
-  emitWarning
-} from './utils';
+
 import type { Document } from './bson';
+import { MongoCredentials } from './cmap/auth/mongo_credentials';
+import { AUTH_MECHS_AUTH_SRC_EXTERNAL, AuthMechanism } from './cmap/auth/providers';
+import { Compressor, CompressorName } from './cmap/wire_protocol/compression';
+import { Encrypter } from './encrypter';
+import { MongoAPIError, MongoInvalidArgumentError, MongoParseError } from './error';
+import { Logger, LoggerLevel } from './logger';
 import {
   DriverInfo,
   MongoClient,
@@ -27,12 +19,21 @@ import {
   ServerApi,
   ServerApiVersion
 } from './mongo_client';
-import { MongoCredentials } from './cmap/auth/mongo_credentials';
-import type { TagSet } from './sdam/server_description';
-import { Logger, LoggerLevel } from './logger';
 import { PromiseProvider } from './promise_provider';
-import { Encrypter } from './encrypter';
-import { Compressor, CompressorName } from './cmap/wire_protocol/compression';
+import { ReadConcern, ReadConcernLevel } from './read_concern';
+import { ReadPreference, ReadPreferenceMode } from './read_preference';
+import type { TagSet } from './sdam/server_description';
+import {
+  AnyOptions,
+  Callback,
+  DEFAULT_PK_FACTORY,
+  emitWarning,
+  HostAddress,
+  isRecord,
+  makeClientMetadata,
+  setDifference
+} from './utils';
+import { W, WriteConcern } from './write_concern';
 
 const VALID_TXT_RECORDS = ['authSource', 'replicaSet', 'loadBalanced'];
 
@@ -75,7 +76,7 @@ export function resolveSRVRecord(options: MongoOptions, callback: Callback<HostA
 
   // Resolve the SRV record and use the result as the list of hosts to connect to.
   const lookupAddress = options.srvHost;
-  dns.resolveSrv(`_mongodb._tcp.${lookupAddress}`, (err, addresses) => {
+  dns.resolveSrv(`_${options.srvServiceName}._tcp.${lookupAddress}`, (err, addresses) => {
     if (err) return callback(err);
 
     if (addresses.length === 0) {
@@ -92,7 +93,7 @@ export function resolveSRVRecord(options: MongoOptions, callback: Callback<HostA
       HostAddress.fromString(`${r.name}:${r.port ?? 27017}`)
     );
 
-    const lbError = validateLoadBalancedOptions(hostAddresses, options);
+    const lbError = validateLoadBalancedOptions(hostAddresses, options, true);
     if (lbError) {
       return callback(lbError);
     }
@@ -116,15 +117,20 @@ export function resolveSRVRecord(options: MongoOptions, callback: Callback<HostA
           );
         }
 
+        if (VALID_TXT_RECORDS.some(option => txtRecordOptions.get(option) === '')) {
+          return callback(new MongoParseError('Cannot have empty URI params in DNS TXT Record'));
+        }
+
         const source = txtRecordOptions.get('authSource') ?? undefined;
         const replicaSet = txtRecordOptions.get('replicaSet') ?? undefined;
         const loadBalanced = txtRecordOptions.get('loadBalanced') ?? undefined;
 
-        if (source === '' || replicaSet === '') {
-          return callback(new MongoParseError('Cannot have empty URI params in DNS TXT Record'));
-        }
-
-        if (!options.userSpecifiedAuthSource && source) {
+        if (
+          !options.userSpecifiedAuthSource &&
+          source &&
+          options.credentials &&
+          !AUTH_MECHS_AUTH_SRC_EXTERNAL.has(options.credentials.mechanism)
+        ) {
           options.credentials = MongoCredentials.merge(options.credentials, { source });
         }
 
@@ -136,7 +142,11 @@ export function resolveSRVRecord(options: MongoOptions, callback: Callback<HostA
           options.loadBalanced = true;
         }
 
-        const lbError = validateLoadBalancedOptions(hostAddresses, options);
+        if (options.replicaSet && options.srvMaxHosts > 0) {
+          return callback(new MongoParseError('Cannot combine replicaSet option with srvMaxHosts'));
+        }
+
+        const lbError = validateLoadBalancedOptions(hostAddresses, options, true);
         if (lbError) {
           return callback(lbError);
         }
@@ -251,13 +261,6 @@ export function parseOptions(
 
   const mongoOptions = Object.create(null);
   mongoOptions.hosts = isSRV ? [] : hosts.map(HostAddress.fromString);
-  if (isSRV) {
-    // SRV Record is resolved upon connecting
-    mongoOptions.srvHost = hosts[0];
-    if (!url.searchParams.has('tls') && !url.searchParams.has('ssl')) {
-      options.tls = true;
-    }
-  }
 
   const urlOptions = new CaseInsensitiveMap();
 
@@ -289,17 +292,6 @@ export function parseOptions(
       throw new MongoAPIError('URI cannot contain options with no value');
     }
 
-    if (key.toLowerCase() === 'serverapi') {
-      throw new MongoParseError(
-        'URI cannot contain `serverApi`, it can only be passed to the client'
-      );
-    }
-
-    if (key.toLowerCase() === 'authsource' && urlOptions.has('authSource')) {
-      // If authSource is an explicit key in the urlOptions we need to remove the implicit dbName
-      urlOptions.delete('authSource');
-    }
-
     if (!urlOptions.has(key)) {
       urlOptions.set(key, values);
     }
@@ -309,10 +301,20 @@ export function parseOptions(
     Object.entries(options).filter(([, v]) => v != null)
   );
 
+  // Validate options that can only be provided by one of uri or object
+
+  if (urlOptions.has('serverApi')) {
+    throw new MongoParseError(
+      'URI cannot contain `serverApi`, it can only be passed to the client'
+    );
+  }
+
   if (objectOptions.has('loadBalanced')) {
     throw new MongoParseError('loadBalanced is only a valid option in the URI');
   }
 
+  // All option collection
+
   const allOptions = new CaseInsensitiveMap();
 
   const allKeys = new Set<string>([
@@ -360,6 +362,8 @@ export function parseOptions(
     );
   }
 
+  // Option parsing and setting
+
   for (const [key, descriptor] of Object.entries(OPTIONS)) {
     const values = allOptions.get(key);
     if (!values || values.length === 0) continue;
@@ -401,25 +405,78 @@ export function parseOptions(
 
   if (options.promiseLibrary) PromiseProvider.set(options.promiseLibrary);
 
-  if (mongoOptions.directConnection && typeof mongoOptions.srvHost === 'string') {
-    throw new MongoAPIError('SRV URI does not support directConnection');
-  }
-
-  const lbError = validateLoadBalancedOptions(hosts, mongoOptions);
+  const lbError = validateLoadBalancedOptions(hosts, mongoOptions, isSRV);
   if (lbError) {
     throw lbError;
   }
+  if (mongoClient && mongoOptions.autoEncryption) {
+    Encrypter.checkForMongoCrypt();
+    mongoOptions.encrypter = new Encrypter(mongoClient, uri, options);
+    mongoOptions.autoEncrypter = mongoOptions.encrypter.autoEncrypter;
+  }
+
+  // Potential SRV Overrides and SRV connection string validations
 
-  // Potential SRV Overrides
   mongoOptions.userSpecifiedAuthSource =
     objectOptions.has('authSource') || urlOptions.has('authSource');
   mongoOptions.userSpecifiedReplicaSet =
     objectOptions.has('replicaSet') || urlOptions.has('replicaSet');
 
-  if (mongoClient && mongoOptions.autoEncryption) {
-    Encrypter.checkForMongoCrypt();
-    mongoOptions.encrypter = new Encrypter(mongoClient, uri, options);
-    mongoOptions.autoEncrypter = mongoOptions.encrypter.autoEncrypter;
+  if (isSRV) {
+    // SRV Record is resolved upon connecting
+    mongoOptions.srvHost = hosts[0];
+
+    if (mongoOptions.directConnection) {
+      throw new MongoAPIError('SRV URI does not support directConnection');
+    }
+
+    if (mongoOptions.srvMaxHosts > 0 && typeof mongoOptions.replicaSet === 'string') {
+      throw new MongoParseError('Cannot use srvMaxHosts option with replicaSet');
+    }
+
+    // SRV turns on TLS by default, but users can override and turn it off
+    const noUserSpecifiedTLS = !objectOptions.has('tls') && !urlOptions.has('tls');
+    const noUserSpecifiedSSL = !objectOptions.has('ssl') && !urlOptions.has('ssl');
+    if (noUserSpecifiedTLS && noUserSpecifiedSSL) {
+      mongoOptions.tls = true;
+    }
+  } else {
+    const userSpecifiedSrvOptions =
+      urlOptions.has('srvMaxHosts') ||
+      objectOptions.has('srvMaxHosts') ||
+      urlOptions.has('srvServiceName') ||
+      objectOptions.has('srvServiceName');
+
+    if (userSpecifiedSrvOptions) {
+      throw new MongoParseError(
+        'Cannot use srvMaxHosts or srvServiceName with a non-srv connection string'
+      );
+    }
+  }
+
+  if (
+    !mongoOptions.proxyHost &&
+    (mongoOptions.proxyPort || mongoOptions.proxyUsername || mongoOptions.proxyPassword)
+  ) {
+    throw new MongoParseError('Must specify proxyHost if other proxy options are passed');
+  }
+
+  if (
+    (mongoOptions.proxyUsername && !mongoOptions.proxyPassword) ||
+    (!mongoOptions.proxyUsername && mongoOptions.proxyPassword)
+  ) {
+    throw new MongoParseError('Can only specify both of proxy username/password or neither');
+  }
+
+  if (
+    urlOptions.get('proxyHost')?.length > 1 ||
+    urlOptions.get('proxyPort')?.length > 1 ||
+    urlOptions.get('proxyUsername')?.length > 1 ||
+    urlOptions.get('proxyPassword')?.length > 1
+  ) {
+    throw new MongoParseError(
+      'Proxy options cannot be specified multiple times in the connection string'
+    );
   }
 
   return mongoOptions;
@@ -427,7 +484,8 @@ export function parseOptions(
 
 function validateLoadBalancedOptions(
   hosts: HostAddress[] | string[],
-  mongoOptions: MongoOptions
+  mongoOptions: MongoOptions,
+  isSrv: boolean
 ): MongoParseError | undefined {
   if (mongoOptions.loadBalanced) {
     if (hosts.length > 1) {
@@ -439,6 +497,10 @@ function validateLoadBalancedOptions(
     if (mongoOptions.directConnection) {
       return new MongoParseError(LB_DIRECT_CONNECTION_ERROR);
     }
+
+    if (isSrv && mongoOptions.srvMaxHosts > 0) {
+      return new MongoParseError('Cannot limit srv hosts with loadBalanced enabled');
+    }
   }
 }
 
@@ -538,9 +600,7 @@ export const OPTIONS = {
       let source = options.credentials?.source;
       if (
         mechanism === AuthMechanism.MONGODB_PLAIN ||
-        mechanism === AuthMechanism.MONGODB_GSSAPI ||
-        mechanism === AuthMechanism.MONGODB_AWS ||
-        mechanism === AuthMechanism.MONGODB_X509
+        AUTH_MECHS_AUTH_SRC_EXTERNAL.has(mechanism)
       ) {
         // some mechanisms have '$external' as the Auth Source
         source = '$external';
@@ -657,6 +717,7 @@ export const OPTIONS = {
       });
     }
   },
+  enableUtf8Validation: { type: 'boolean', default: true },
   family: {
     transform({ name, values: [value] }): 4 | 6 {
       const transformValue = getInt(name, value);
@@ -824,6 +885,18 @@ export const OPTIONS = {
   promoteValues: {
     type: 'boolean'
   },
+  proxyHost: {
+    type: 'string'
+  },
+  proxyPassword: {
+    type: 'string'
+  },
+  proxyPort: {
+    type: 'uint'
+  },
+  proxyUsername: {
+    type: 'string'
+  },
   raw: {
     default: false,
     type: 'boolean'
@@ -924,6 +997,14 @@ export const OPTIONS = {
     default: 0,
     type: 'uint'
   },
+  srvMaxHosts: {
+    type: 'uint',
+    default: 0
+  },
+  srvServiceName: {
+    type: 'string',
+    default: 'mongodb'
+  },
   ssl: {
     target: 'tls',
     type: 'boolean'

package/src/constants.ts

@@ -4,3 +4,119 @@ export const SYSTEM_PROFILE_COLLECTION = 'system.profile';
 export const SYSTEM_USER_COLLECTION = 'system.users';
 export const SYSTEM_COMMAND_COLLECTION = '$cmd';
 export const SYSTEM_JS_COLLECTION = 'system.js';
+
+// events
+export const ERROR = 'error' as const;
+export const TIMEOUT = 'timeout' as const;
+export const CLOSE = 'close' as const;
+export const OPEN = 'open' as const;
+export const CONNECT = 'connect' as const;
+export const CLOSED = 'closed' as const;
+export const ENDED = 'ended' as const;
+export const MESSAGE = 'message' as const;
+export const PINNED = 'pinned' as const;
+export const UNPINNED = 'unpinned' as const;
+export const DESCRIPTION_RECEIVED = 'descriptionReceived';
+export const SERVER_OPENING = 'serverOpening' as const;
+export const SERVER_CLOSED = 'serverClosed' as const;
+export const SERVER_DESCRIPTION_CHANGED = 'serverDescriptionChanged' as const;
+export const TOPOLOGY_OPENING = 'topologyOpening' as const;
+export const TOPOLOGY_CLOSED = 'topologyClosed' as const;
+export const TOPOLOGY_DESCRIPTION_CHANGED = 'topologyDescriptionChanged' as const;
+export const CONNECTION_POOL_CREATED = 'connectionPoolCreated' as const;
+export const CONNECTION_POOL_CLOSED = 'connectionPoolClosed' as const;
+export const CONNECTION_POOL_CLEARED = 'connectionPoolCleared' as const;
+export const CONNECTION_CREATED = 'connectionCreated' as const;
+export const CONNECTION_READY = 'connectionReady' as const;
+export const CONNECTION_CLOSED = 'connectionClosed' as const;
+export const CONNECTION_CHECK_OUT_STARTED = 'connectionCheckOutStarted' as const;
+export const CONNECTION_CHECK_OUT_FAILED = 'connectionCheckOutFailed' as const;
+export const CONNECTION_CHECKED_OUT = 'connectionCheckedOut' as const;
+export const CONNECTION_CHECKED_IN = 'connectionCheckedIn' as const;
+export const CLUSTER_TIME_RECEIVED = 'clusterTimeReceived' as const;
+export const COMMAND_STARTED = 'commandStarted' as const;
+export const COMMAND_SUCCEEDED = 'commandSucceeded' as const;
+export const COMMAND_FAILED = 'commandFailed' as const;
+export const SERVER_HEARTBEAT_STARTED = 'serverHeartbeatStarted' as const;
+export const SERVER_HEARTBEAT_SUCCEEDED = 'serverHeartbeatSucceeded' as const;
+export const SERVER_HEARTBEAT_FAILED = 'serverHeartbeatFailed' as const;
+
+/** @public */
+export const HEARTBEAT_EVENTS = Object.freeze([
+  SERVER_HEARTBEAT_STARTED,
+  SERVER_HEARTBEAT_SUCCEEDED,
+  SERVER_HEARTBEAT_FAILED
+] as const);
+
+/** @public */
+export const CMAP_EVENTS = Object.freeze([
+  CONNECTION_POOL_CREATED,
+  CONNECTION_POOL_CLOSED,
+  CONNECTION_CREATED,
+  CONNECTION_READY,
+  CONNECTION_CLOSED,
+  CONNECTION_CHECK_OUT_STARTED,
+  CONNECTION_CHECK_OUT_FAILED,
+  CONNECTION_CHECKED_OUT,
+  CONNECTION_CHECKED_IN,
+  CONNECTION_POOL_CLEARED
+] as const);
+
+/** @public */
+export const TOPOLOGY_EVENTS = Object.freeze([
+  SERVER_OPENING,
+  SERVER_CLOSED,
+  SERVER_DESCRIPTION_CHANGED,
+  TOPOLOGY_OPENING,
+  TOPOLOGY_CLOSED,
+  TOPOLOGY_DESCRIPTION_CHANGED,
+  ERROR,
+  TIMEOUT,
+  CLOSE
+] as const);
+
+/** @public */
+export const APM_EVENTS = Object.freeze([
+  COMMAND_STARTED,
+  COMMAND_SUCCEEDED,
+  COMMAND_FAILED
+] as const);
+
+/**
+ * All events that we relay to the `Topology`
+ * @internal
+ */
+export const SERVER_RELAY_EVENTS = Object.freeze([
+  SERVER_HEARTBEAT_STARTED,
+  SERVER_HEARTBEAT_SUCCEEDED,
+  SERVER_HEARTBEAT_FAILED,
+  COMMAND_STARTED,
+  COMMAND_SUCCEEDED,
+  COMMAND_FAILED,
+  ...CMAP_EVENTS
+] as const);
+
+/**
+ * All events we listen to from `Server` instances, but do not forward to the client
+ * @internal
+ */
+export const LOCAL_SERVER_EVENTS = Object.freeze([
+  CONNECT,
+  DESCRIPTION_RECEIVED,
+  CLOSED,
+  ENDED
+] as const);
+
+/** @public */
+export const MONGO_CLIENT_EVENTS = Object.freeze([
+  ...CMAP_EVENTS,
+  ...APM_EVENTS,
+  ...TOPOLOGY_EVENTS,
+  ...HEARTBEAT_EVENTS
+] as const);
+
+/**
+ * @internal
+ * The legacy hello command that was deprecated in MongoDB 5.0.
+ */
+export const LEGACY_HELLO_COMMAND = 'ismaster';

package/src/cursor/abstract_cursor.ts

@@ -1,22 +1,24 @@
-import { Callback, maybePromise, MongoDBNamespace, ns } from '../utils';
-import { Long, Document, BSONSerializeOptions, pluckBSONSerializeOptions } from '../bson';
-import { ClientSession, maybeClearPinnedConnection } from '../sessions';
+import { Readable, Transform } from 'stream';
+
+import { BSONSerializeOptions, Document, Long, pluckBSONSerializeOptions } from '../bson';
 import {
   AnyError,
-  MongoRuntimeError,
-  MongoNetworkError,
-  MongoInvalidArgumentError,
   MongoCursorExhaustedError,
-  MongoTailableCursorError,
-  MongoCursorInUseError
+  MongoCursorInUseError,
+  MongoInvalidArgumentError,
+  MongoNetworkError,
+  MongoRuntimeError,
+  MongoTailableCursorError
 } from '../error';
+import { TODO_NODE_3286, TypedEventEmitter } from '../mongo_types';
+import { executeOperation, ExecutionResult } from '../operations/execute_operation';
+import { GetMoreOperation } from '../operations/get_more';
+import { ReadConcern, ReadConcernLike } from '../read_concern';
 import { ReadPreference, ReadPreferenceLike } from '../read_preference';
 import type { Server } from '../sdam/server';
 import type { Topology } from '../sdam/topology';
-import { Readable, Transform } from 'stream';
-import type { ExecutionResult } from '../operations/execute_operation';
-import { ReadConcern, ReadConcernLike } from '../read_concern';
-import { TODO_NODE_3286, TypedEventEmitter } from '../mongo_types';
+import { ClientSession, maybeClearPinnedConnection } from '../sessions';
+import { Callback, maybePromise, MongoDBNamespace, ns } from '../utils';
 
 /** @internal */
 const kId = Symbol('id');
@@ -610,16 +612,13 @@ export abstract class AbstractCursor<
       return;
     }
 
-    server.getMore(
-      cursorNs,
-      cursorId,
-      {
-        ...this[kOptions],
-        session: this[kSession],
-        batchSize
-      },
-      callback
-    );
+    const getMoreOperation = new GetMoreOperation(cursorNs, cursorId, server, {
+      ...this[kOptions],
+      session: this[kSession],
+      batchSize
+    });
+
+    executeOperation(this.topology, getMoreOperation, callback);
   }
 }
 

package/src/cursor/aggregation_cursor.ts

@@ -1,14 +1,14 @@
+import type { Document } from '../bson';
+import type { ExplainVerbosityLike } from '../explain';
 import { AggregateOperation, AggregateOptions } from '../operations/aggregate';
-import { AbstractCursor, assertUninitialized } from './abstract_cursor';
 import { executeOperation, ExecutionResult } from '../operations/execute_operation';
-import { mergeOptions } from '../utils';
-import type { Document } from '../bson';
-import type { Sort } from '../sort';
 import type { Topology } from '../sdam/topology';
-import type { Callback, MongoDBNamespace } from '../utils';
 import type { ClientSession } from '../sessions';
+import type { Sort } from '../sort';
+import type { Callback, MongoDBNamespace } from '../utils';
+import { mergeOptions } from '../utils';
 import type { AbstractCursorOptions } from './abstract_cursor';
-import type { ExplainVerbosityLike } from '../explain';
+import { AbstractCursor, assertUninitialized } from './abstract_cursor';
 
 /** @public */
 export interface AggregationCursorOptions extends AbstractCursorOptions, AggregateOptions {}

package/src/cursor/find_cursor.ts

@@ -1,16 +1,16 @@
 import type { Document } from '../bson';
 import { MongoInvalidArgumentError, MongoTailableCursorError } from '../error';
 import type { ExplainVerbosityLike } from '../explain';
+import type { CollationOptions } from '../operations/command';
 import { CountOperation, CountOptions } from '../operations/count';
 import { executeOperation, ExecutionResult } from '../operations/execute_operation';
 import { FindOperation, FindOptions } from '../operations/find';
-import { mergeOptions } from '../utils';
 import type { Hint } from '../operations/operation';
-import type { CollationOptions } from '../operations/command';
 import type { Topology } from '../sdam/topology';
 import type { ClientSession } from '../sessions';
 import { formatSort, Sort, SortDirection } from '../sort';
 import type { Callback, MongoDBNamespace } from '../utils';
+import { mergeOptions } from '../utils';
 import { AbstractCursor, assertUninitialized } from './abstract_cursor';
 
 /** @internal */