feat: Add MongoOptions builder

Parse options from uri and object creating
frozen MongoOptions interface object.

NODE-2699

Author: nbbeeken

src/cmap/auth/defaultAuthProviders.ts

@@ -7,25 +7,28 @@ import { MongoDBAWS } from './mongodb_aws';
 import type { AuthProvider } from './auth_provider';
 
 /** @public */
-export enum AuthMechanism {
-  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'
-}
+export const AuthMechanismEnum = {
+  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 AuthMechanismEnum[keyof typeof AuthMechanismEnum];
 
 export const AUTH_PROVIDERS = {
-  [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()
+  [AuthMechanismEnum.MONGODB_AWS]: new MongoDBAWS(),
+  [AuthMechanismEnum.MONGODB_CR]: new MongoCR(),
+  [AuthMechanismEnum.MONGODB_GSSAPI]: new GSSAPI(),
+  [AuthMechanismEnum.MONGODB_PLAIN]: new Plain(),
+  [AuthMechanismEnum.MONGODB_SCRAM_SHA1]: new ScramSHA1(),
+  [AuthMechanismEnum.MONGODB_SCRAM_SHA256]: new ScramSHA256(),
+  [AuthMechanismEnum.MONGODB_X509]: new X509()
 };
 
 // TODO: We can make auth mechanism more functional since we pass around a context object

src/cmap/auth/mongo_credentials.ts

@@ -1,7 +1,7 @@
 // Resolves the default auth mechanism according to
 
 import type { Document } from '../../bson';
-import { AuthMechanism } from './defaultAuthProviders';
+import { AuthMechanism, AuthMechanismEnum } from './defaultAuthProviders';
 
 // https://github.com/mongodb/specifications/blob/master/source/auth/auth.rst
 function getDefaultAuthMechanism(ismaster?: Document): AuthMechanism {
@@ -10,18 +10,18 @@ function getDefaultAuthMechanism(ismaster?: Document): AuthMechanism {
     // if it is available, else scram-sha-1
     if (Array.isArray(ismaster.saslSupportedMechs)) {
       return ismaster.saslSupportedMechs.indexOf('SCRAM-SHA-256') >= 0
-        ? AuthMechanism.MONGODB_SCRAM_SHA256
-        : AuthMechanism.MONGODB_SCRAM_SHA1;
+        ? AuthMechanismEnum.MONGODB_SCRAM_SHA256
+        : AuthMechanismEnum.MONGODB_SCRAM_SHA1;
     }
 
     // Fallback to legacy selection method. If wire version >= 3, use scram-sha-1
     if (ismaster.maxWireVersion >= 3) {
-      return AuthMechanism.MONGODB_SCRAM_SHA1;
+      return AuthMechanismEnum.MONGODB_SCRAM_SHA1;
     }
   }
 
   // Default for wireprotocol < 3
-  return AuthMechanism.MONGODB_CR;
+  return AuthMechanismEnum.MONGODB_CR;
 }
 
 /** @public */
@@ -57,7 +57,7 @@ export class MongoCredentials {
     if (!this.source && options.db) {
       this.source = options.db;
     }
-    this.mechanism = options.mechanism || AuthMechanism.MONGODB_DEFAULT;
+    this.mechanism = options.mechanism || AuthMechanismEnum.MONGODB_DEFAULT;
     this.mechanismProperties = options.mechanismProperties || {};
 
     if (this.mechanism.match(/MONGODB-AWS/i)) {

src/cmap/auth/mongodb_aws.ts

@@ -9,7 +9,7 @@ import { maxWireVersion, Callback } from '../../utils';
 import type { BSONSerializeOptions } from '../../bson';
 
 import { aws4 } from '../../deps';
-import { AuthMechanism } from './defaultAuthProviders';
+import { AuthMechanismEnum } from './defaultAuthProviders';
 
 const ASCII_N = 110;
 const AWS_RELATIVE_URI = 'http://169.254.170.2';
@@ -155,7 +155,7 @@ function makeTempCredentials(credentials: MongoCredentials, callback: Callback<M
         username: creds.AccessKeyId,
         password: creds.SecretAccessKey,
         source: credentials.source,
-        mechanism: AuthMechanism.MONGODB_AWS,
+        mechanism: AuthMechanismEnum.MONGODB_AWS,
         mechanismProperties: {
           AWS_SESSION_TOKEN: creds.Token
         }

src/cmap/connect.ts

@@ -2,7 +2,7 @@ import * as net from 'net';
 import * as tls from 'tls';
 import { Connection, ConnectionOptions } from './connection';
 import { MongoError, MongoNetworkError, MongoNetworkTimeoutError, AnyError } from '../error';
-import { defaultAuthProviders, AuthMechanism } from './auth/defaultAuthProviders';
+import { defaultAuthProviders, AuthMechanismEnum } from './auth/defaultAuthProviders';
 import { AuthContext } from './auth/auth_provider';
 import { makeClientMetadata, ClientMetadata, Callback, CallbackWithType } from '../utils';
 import {
@@ -179,7 +179,7 @@ function prepareHandshakeDocument(authContext: AuthContext, callback: Callback<H
       });
 
       let provider;
-      if ((provider = AUTH_PROVIDERS[AuthMechanism.MONGODB_SCRAM_SHA256])) {
+      if ((provider = AUTH_PROVIDERS[AuthMechanismEnum.MONGODB_SCRAM_SHA256])) {
         // This auth mechanism is always present.
         provider.prepare(handshakeDoc, authContext, callback);
         return;

src/cmap/connection.ts

@@ -20,10 +20,10 @@ import type { Server } from '../sdam/server';
 import type { MongoCredentials } from './auth/mongo_credentials';
 import type { CommandOptions } from './wire_protocol/command';
 import type { GetMoreOptions } from './wire_protocol/get_more';
-import type { InsertOptions, UpdateOptions, RemoveOptions } from './wire_protocol/index';
 import type { Stream } from './connect';
 import type { LoggerOptions } from '../logger';
 import type { FindOptions } from '../operations/find';
+import type { WriteCommandOptions } from './wire_protocol/write_command';
 
 const kStream = Symbol('stream');
 const kQueue = Symbol('queue');
@@ -258,15 +258,15 @@ export class Connection extends EventEmitter {
     wp.killCursors(makeServerTrampoline(this), ns, cursorIds, options, callback);
   }
 
-  insert(ns: string, ops: Document[], options: InsertOptions, callback: Callback): void {
+  insert(ns: string, ops: Document[], options: WriteCommandOptions, callback: Callback): void {
     wp.insert(makeServerTrampoline(this), ns, ops, options, callback);
   }
 
-  update(ns: string, ops: Document[], options: UpdateOptions, callback: Callback): void {
+  update(ns: string, ops: Document[], options: WriteCommandOptions, callback: Callback): void {
     wp.update(makeServerTrampoline(this), ns, ops, options, callback);
   }
 
-  remove(ns: string, ops: Document[], options: RemoveOptions, callback: Callback): void {
+  remove(ns: string, ops: Document[], options: WriteCommandOptions, callback: Callback): void {
     wp.remove(makeServerTrampoline(this), ns, ops, options, callback);
   }
 }

src/cmap/wire_protocol/index.ts

@@ -11,40 +11,31 @@ import type { Callback } from '../../utils';
 
 export { writeCommand };
 
-/** @internal */
-export type InsertOptions = WriteCommandOptions;
-
 export function insert(
   server: Server,
   ns: string,
   ops: Document[],
-  options: InsertOptions,
+  options: WriteCommandOptions,
   callback: Callback
 ): void {
   writeCommand(server, 'insert', 'documents', ns, ops, options, callback);
 }
 
-/** @internal */
-export type UpdateOptions = WriteCommandOptions;
-
 export function update(
   server: Server,
   ns: string,
   ops: Document[],
-  options: UpdateOptions,
+  options: WriteCommandOptions,
   callback: Callback
 ): void {
   writeCommand(server, 'update', 'updates', ns, ops, options, callback);
 }
 
-/** @internal */
-export type RemoveOptions = WriteCommandOptions;
-
 export function remove(
   server: Server,
   ns: string,
   ops: Document[],
-  options: RemoveOptions,
+  options: WriteCommandOptions,
   callback: Callback
 ): void {
   writeCommand(server, 'delete', 'deletes', ns, ops, options, callback);