mongodb 4.0.0 → 4.1.2

package/src/connection_string.ts

@@ -6,7 +6,7 @@ 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 { MongoParseError } from './error';
+import { MongoAPIError, MongoInvalidArgumentError, MongoParseError } from './error';
 import {
   AnyOptions,
   Callback,
@@ -32,6 +32,14 @@ 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';
+
+const VALID_TXT_RECORDS = ['authSource', 'replicaSet', 'loadBalanced'];
+
+const LB_SINGLE_HOST_ERROR = 'loadBalanced option only supported with a single host in the URI';
+const LB_REPLICA_SET_ERROR = 'loadBalanced option not supported with a replicaSet option';
+const LB_DIRECT_CONNECTION_ERROR =
+  'loadBalanced option not supported when directConnection is provided';
 
 /**
  * Determines whether a provided address matches the provided parent domain in order
@@ -57,11 +65,12 @@ function matchesParentDomain(srvAddress: string, parentDomain: string): boolean
  */
 export function resolveSRVRecord(options: MongoOptions, callback: Callback<HostAddress[]>): void {
   if (typeof options.srvHost !== 'string') {
-    return callback(new MongoParseError('Cannot resolve empty srv string'));
+    return callback(new MongoAPIError('Option "srvHost" must not be empty'));
   }
 
   if (options.srvHost.split('.').length < 3) {
-    return callback(new MongoParseError('URI does not have hostname, domain name and tld'));
+    // TODO(NODE-3484): Replace with MongoConnectionStringError
+    return callback(new MongoAPIError('URI must include hostname, domain name, and tld'));
   }
 
   // Resolve the SRV record and use the result as the list of hosts to connect to.
@@ -70,14 +79,12 @@ export function resolveSRVRecord(options: MongoOptions, callback: Callback<HostA
     if (err) return callback(err);
 
     if (addresses.length === 0) {
-      return callback(new MongoParseError('No addresses found at host'));
+      return callback(new MongoAPIError('No addresses found at host'));
     }
 
     for (const { name } of addresses) {
       if (!matchesParentDomain(name, lookupAddress)) {
-        return callback(
-          new MongoParseError('Server record does not share hostname with parent URI')
-        );
+        return callback(new MongoAPIError('Server record does not share hostname with parent URI'));
       }
     }
 
@@ -85,6 +92,11 @@ export function resolveSRVRecord(options: MongoOptions, callback: Callback<HostA
       HostAddress.fromString(`${r.name}:${r.port ?? 27017}`)
     );
 
+    const lbError = validateLoadBalancedOptions(hostAddresses, options);
+    if (lbError) {
+      return callback(lbError);
+    }
+
     // Resolve TXT record and add options from there if they exist.
     dns.resolveTxt(lookupAddress, (err, record) => {
       if (err) {
@@ -98,14 +110,15 @@ export function resolveSRVRecord(options: MongoOptions, callback: Callback<HostA
 
         const txtRecordOptions = new URLSearchParams(record[0].join(''));
         const txtRecordOptionKeys = [...txtRecordOptions.keys()];
-        if (txtRecordOptionKeys.some(key => key !== 'authSource' && key !== 'replicaSet')) {
+        if (txtRecordOptionKeys.some(key => !VALID_TXT_RECORDS.includes(key))) {
           return callback(
-            new MongoParseError('Text record must only set `authSource` or `replicaSet`')
+            new MongoParseError(`Text record may only set any of: ${VALID_TXT_RECORDS.join(', ')}`)
           );
         }
 
         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'));
@@ -118,6 +131,15 @@ export function resolveSRVRecord(options: MongoOptions, callback: Callback<HostA
         if (!options.userSpecifiedReplicaSet && replicaSet) {
           options.replicaSet = replicaSet;
         }
+
+        if (loadBalanced === 'true') {
+          options.loadBalanced = true;
+        }
+
+        const lbError = validateLoadBalancedOptions(hostAddresses, options);
+        if (lbError) {
+          return callback(lbError);
+        }
       }
 
       callback(undefined, hostAddresses);
@@ -154,7 +176,7 @@ function getBoolean(name: string, value: unknown): boolean {
   const valueString = String(value).toLowerCase();
   if (TRUTHS.has(valueString)) return true;
   if (FALSEHOODS.has(valueString)) return false;
-  throw new MongoParseError(`For ${name} Expected stringified boolean value, got: ${value}`);
+  throw new MongoParseError(`Expected ${name} to be stringified boolean value, got: ${value}`);
 }
 
 function getInt(name: string, value: unknown): number {
@@ -177,7 +199,7 @@ function toRecord(value: string): Record<string, any> {
   const keyValuePairs = value.split(',');
   for (const keyValue of keyValuePairs) {
     const [key, value] = keyValue.split(':');
-    if (typeof value === 'undefined') {
+    if (value == null) {
       throw new MongoParseError('Cannot have undefined values in key value pairs');
     }
     try {
@@ -219,7 +241,7 @@ export function parseOptions(
   mongoClient: MongoClient | MongoClientOptions | undefined = undefined,
   options: MongoClientOptions = {}
 ): MongoOptions {
-  if (typeof mongoClient !== 'undefined' && !(mongoClient instanceof MongoClient)) {
+  if (mongoClient != null && !(mongoClient instanceof MongoClient)) {
     options = mongoClient;
     mongoClient = undefined;
   }
@@ -264,7 +286,7 @@ export function parseOptions(
     const values = [...url.searchParams.getAll(key)];
 
     if (values.includes('')) {
-      throw new MongoParseError('URI cannot contain options with no value');
+      throw new MongoAPIError('URI cannot contain options with no value');
     }
 
     if (key.toLowerCase() === 'serverapi') {
@@ -284,9 +306,13 @@ export function parseOptions(
   }
 
   const objectOptions = new CaseInsensitiveMap(
-    Object.entries(options).filter(([, v]) => (v ?? null) !== null)
+    Object.entries(options).filter(([, v]) => v != null)
   );
 
+  if (objectOptions.has('loadBalanced')) {
+    throw new MongoParseError('loadBalanced is only a valid option in the URI');
+  }
+
   const allOptions = new CaseInsensitiveMap();
 
   const allKeys = new Set<string>([
@@ -309,6 +335,19 @@ export function parseOptions(
     allOptions.set(key, values);
   }
 
+  if (allOptions.has('tlsCertificateKeyFile') && !allOptions.has('tlsCertificateFile')) {
+    allOptions.set('tlsCertificateFile', allOptions.get('tlsCertificateKeyFile'));
+  }
+
+  if (allOptions.has('tls') || allOptions.has('ssl')) {
+    const tlsAndSslOpts = (allOptions.get('tls') || [])
+      .concat(allOptions.get('ssl') || [])
+      .map(getBoolean.bind(null, 'tls/ssl'));
+    if (new Set(tlsAndSslOpts).size !== 1) {
+      throw new MongoParseError('All values of tls/ssl must be the same.');
+    }
+  }
+
   const unsupportedOptions = setDifference(
     allKeys,
     Array.from(Object.keys(OPTIONS)).map(s => s.toLowerCase())
@@ -358,24 +397,17 @@ export function parseOptions(
     mongoOptions.dbName = 'test';
   }
 
-  if (allOptions.has('tls')) {
-    if (new Set(allOptions.get('tls')?.map(getBoolean)).size !== 1) {
-      throw new MongoParseError('All values of tls must be the same.');
-    }
-  }
-
-  if (allOptions.has('ssl')) {
-    if (new Set(allOptions.get('ssl')?.map(getBoolean)).size !== 1) {
-      throw new MongoParseError('All values of ssl must be the same.');
-    }
-  }
-
   checkTLSOptions(mongoOptions);
 
   if (options.promiseLibrary) PromiseProvider.set(options.promiseLibrary);
 
   if (mongoOptions.directConnection && typeof mongoOptions.srvHost === 'string') {
-    throw new MongoParseError('directConnection not supported with SRV URI');
+    throw new MongoAPIError('SRV URI does not support directConnection');
+  }
+
+  const lbError = validateLoadBalancedOptions(hosts, mongoOptions);
+  if (lbError) {
+    throw lbError;
   }
 
   // Potential SRV Overrides
@@ -393,6 +425,23 @@ export function parseOptions(
   return mongoOptions;
 }
 
+function validateLoadBalancedOptions(
+  hosts: HostAddress[] | string[],
+  mongoOptions: MongoOptions
+): MongoParseError | undefined {
+  if (mongoOptions.loadBalanced) {
+    if (hosts.length > 1) {
+      return new MongoParseError(LB_SINGLE_HOST_ERROR);
+    }
+    if (mongoOptions.replicaSet) {
+      return new MongoParseError(LB_REPLICA_SET_ERROR);
+    }
+    if (mongoOptions.directConnection) {
+      return new MongoParseError(LB_DIRECT_CONNECTION_ERROR);
+    }
+  }
+}
+
 function setOption(
   mongoOptions: any,
   key: string,
@@ -418,7 +467,7 @@ function setOption(
       mongoOptions[name] = getUint(name, values[0]);
       break;
     case 'string':
-      if (values[0] === undefined) {
+      if (values[0] == null) {
         break;
       }
       mongoOptions[name] = String(values[0]);
@@ -564,12 +613,22 @@ export const OPTIONS = {
     target: 'compressors',
     transform({ values }) {
       const compressionList = new Set();
-      for (const compVal of values as string[]) {
-        for (const c of compVal.split(',')) {
-          if (['none', 'snappy', 'zlib'].includes(String(c))) {
+      for (const compVal of values as (CompressorName[] | string)[]) {
+        const compValArray = typeof compVal === 'string' ? compVal.split(',') : compVal;
+        if (!Array.isArray(compValArray)) {
+          throw new MongoInvalidArgumentError(
+            'compressors must be an array or a comma-delimited list of strings'
+          );
+        }
+        for (const c of compValArray) {
+          if (Object.keys(Compressor).includes(String(c))) {
             compressionList.add(String(c));
           } else {
-            throw new MongoParseError(`${c} is not a valid compression mechanism`);
+            throw new MongoInvalidArgumentError(
+              `${c} is not a valid compression mechanism. Must be one of: ${Object.keys(
+                Compressor
+              )}.`
+            );
           }
         }
       }
@@ -670,6 +729,10 @@ export const OPTIONS = {
     default: 120000,
     type: 'uint'
   },
+  loadBalanced: {
+    default: false,
+    type: 'boolean'
+  },
   localThresholdMS: {
     default: 15,
     type: 'uint'
@@ -724,7 +787,7 @@ export const OPTIONS = {
     type: 'uint'
   },
   monitorCommands: {
-    default: true,
+    default: false,
     type: 'boolean'
   },
   name: {
@@ -1051,6 +1114,6 @@ export const OPTIONS = {
 
 export const DEFAULT_OPTIONS = new CaseInsensitiveMap(
   Object.entries(OPTIONS)
-    .filter(([, descriptor]) => typeof descriptor.default !== 'undefined')
+    .filter(([, descriptor]) => descriptor.default != null)
     .map(([k, d]) => [k, d.default])
 );