fix: remove Enum suffix

Author: nbbeeken

src/cmap/auth/defaultAuthProviders.ts

@@ -7,7 +7,7 @@ import { MongoDBAWS } from './mongodb_aws';
 import type { AuthProvider } from './auth_provider';
 
 /** @public */
-export const AuthMechanismEnum = {
+export const AuthMechanism = {
   MONGODB_AWS: 'MONGODB-AWS',
   MONGODB_CR: 'MONGODB-CR',
   MONGODB_DEFAULT: 'DEFAULT',
@@ -19,16 +19,16 @@ export const AuthMechanismEnum = {
 } as const;
 
 /** @public */
-export type AuthMechanism = typeof AuthMechanismEnum[keyof typeof AuthMechanismEnum];
+export type AuthMechanismId = typeof AuthMechanism[keyof typeof AuthMechanism];
 
 export const AUTH_PROVIDERS = {
-  [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()
+  [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()
 };
 
 // TODO: We can make auth mechanism more functional since we pass around a context object

src/cmap/auth/mongo_credentials.ts

@@ -2,27 +2,27 @@
 
 import type { Document } from '../../bson';
 import { MongoParseError } from '../../error';
-import { AuthMechanism, AuthMechanismEnum } from './defaultAuthProviders';
+import { AuthMechanismId, AuthMechanism } from './defaultAuthProviders';
 
 // https://github.com/mongodb/specifications/blob/master/source/auth/auth.rst
-function getDefaultAuthMechanism(ismaster?: Document): AuthMechanism {
+function getDefaultAuthMechanism(ismaster?: Document): AuthMechanismId {
   if (ismaster) {
     // If ismaster contains saslSupportedMechs, use scram-sha-256
     // if it is available, else scram-sha-1
     if (Array.isArray(ismaster.saslSupportedMechs)) {
       return ismaster.saslSupportedMechs.indexOf('SCRAM-SHA-256') >= 0
-        ? AuthMechanismEnum.MONGODB_SCRAM_SHA256
-        : AuthMechanismEnum.MONGODB_SCRAM_SHA1;
+        ? AuthMechanism.MONGODB_SCRAM_SHA256
+        : AuthMechanism.MONGODB_SCRAM_SHA1;
     }
 
     // Fallback to legacy selection method. If wire version >= 3, use scram-sha-1
     if (ismaster.maxWireVersion >= 3) {
-      return AuthMechanismEnum.MONGODB_SCRAM_SHA1;
+      return AuthMechanism.MONGODB_SCRAM_SHA1;
     }
   }
 
   // Default for wireprotocol < 3
-  return AuthMechanismEnum.MONGODB_CR;
+  return AuthMechanism.MONGODB_CR;
 }
 
 /** @public */
@@ -31,7 +31,7 @@ export interface MongoCredentialsOptions {
   password: string;
   source: string;
   db?: string;
-  mechanism?: AuthMechanism;
+  mechanism?: AuthMechanismId;
   mechanismProperties: Document;
 }
 
@@ -47,7 +47,7 @@ export class MongoCredentials {
   /** The database that the user should authenticate against */
   readonly source: string;
   /** The method used to authenticate */
-  readonly mechanism: AuthMechanism;
+  readonly mechanism: AuthMechanismId;
   /** Special properties used by some types of auth mechanisms */
   readonly mechanismProperties: Document;
 
@@ -58,7 +58,7 @@ export class MongoCredentials {
     if (!this.source && options.db) {
       this.source = options.db;
     }
-    this.mechanism = options.mechanism || AuthMechanismEnum.MONGODB_DEFAULT;
+    this.mechanism = options.mechanism || AuthMechanism.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 { AuthMechanismEnum } from './defaultAuthProviders';
+import { AuthMechanism } 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: AuthMechanismEnum.MONGODB_AWS,
+        mechanism: AuthMechanism.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, AuthMechanismEnum } from './auth/defaultAuthProviders';
+import { defaultAuthProviders, AuthMechanism } 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[AuthMechanismEnum.MONGODB_SCRAM_SHA256])) {
+      if ((provider = AUTH_PROVIDERS[AuthMechanism.MONGODB_SCRAM_SHA256])) {
         // This auth mechanism is always present.
         provider.prepare(handshakeDoc, authContext, callback);
         return;

src/connection_string.ts

@@ -2,9 +2,9 @@ import * as url from 'url';
 import * as qs from 'querystring';
 import * as dns from 'dns';
 import { URL } from 'url';
-import { AuthMechanismEnum } from './cmap/auth/defaultAuthProviders';
-import { ReadPreference, ReadPreferenceMode } from './read_preference';
-import { ReadConcern, ReadConcernLevel } from './read_concern';
+import { AuthMechanism } from './cmap/auth/defaultAuthProviders';
+import { ReadPreference, ReadPreferenceModeId } from './read_preference';
+import { ReadConcern, ReadConcernLevelId } from './read_concern';
 import { W, WriteConcern } from './write_concern';
 import { MongoParseError } from './error';
 import type { AnyOptions, Callback } from './utils';
@@ -1100,7 +1100,7 @@ export const OPTIONS: Record<keyof MongoClientOptions, OptionDescriptor> = {
   authMechanism: {
     rename: 'credentials',
     transform({ options, values: [value] }): MongoCredentials {
-      const mechanisms = Object.values(AuthMechanismEnum);
+      const mechanisms = Object.values(AuthMechanism);
       const [mechanism] = mechanisms.filter(m => m.match(RegExp(String.raw`\b${value}\b`, 'i')));
       if (!mechanism) {
         throw new TypeError(`authMechanism one of ${mechanisms}, got ${value}`);
@@ -1403,7 +1403,7 @@ export const OPTIONS: Record<keyof MongoClientOptions, OptionDescriptor> = {
     transform({ values: [level], options }) {
       return ReadConcern.fromOptions({
         ...options.readConcern,
-        level: level as ReadConcernLevel
+        level: level as ReadConcernLevelId
       });
     }
   },
@@ -1423,7 +1423,7 @@ export const OPTIONS: Record<keyof MongoClientOptions, OptionDescriptor> = {
           maxStalenessSeconds: options.readPreference?.maxStalenessSeconds
         };
         return new ReadPreference(
-          value as ReadPreferenceMode,
+          value as ReadPreferenceModeId,
           options.readPreference?.tags,
           rpOpts
         );

src/index.ts

@@ -104,7 +104,7 @@ export type {
   OperationTime,
   ResumeOptions
 } from './change_stream';
-export type { AuthMechanism, AuthMechanismEnum } from './cmap/auth/defaultAuthProviders';
+export type { AuthMechanism, AuthMechanismId } from './cmap/auth/defaultAuthProviders';
 export type { MongoCredentials, MongoCredentialsOptions } from './cmap/auth/mongo_credentials';
 export type {
   WriteProtocolMessageType,
@@ -176,7 +176,7 @@ export type {
   PkFactory,
   MongoURIOptions,
   LogLevel,
-  LogLevelEnum,
+  LogLevelId,
   Auth,
   DriverInfo
 } from './mongo_client';
@@ -234,13 +234,13 @@ export type { ValidateCollectionOptions } from './operations/validate_collection
 export type {
   ReadConcern,
   ReadConcernLike,
-  ReadConcernLevelEnum,
-  ReadConcernLevel
+  ReadConcernLevel,
+  ReadConcernLevelId
 } from './read_concern';
 export type {
   ReadPreferenceLike,
+  ReadPreferenceModeId,
   ReadPreferenceMode,
-  ReadPreferenceModeEnum,
   ReadPreferenceOptions,
   ReadPreferenceLikeOptions,
   ReadPreferenceFromOptions,

src/mongo_client.ts

@@ -1,19 +1,19 @@
 import { Db, DbOptions } from './db';
 import { EventEmitter } from 'events';
 import { ChangeStream, ChangeStreamOptions } from './change_stream';
-import { ReadPreference, ReadPreferenceMode } from './read_preference';
+import { ReadPreference, ReadPreferenceModeId } from './read_preference';
 import { MongoError, AnyError } from './error';
 import { WriteConcern, WriteConcernOptions } from './write_concern';
 import { maybePromise, MongoDBNamespace, Callback } from './utils';
 import { deprecate } from 'util';
 import { connect, validOptions } from './operations/connect';
 import { PromiseProvider } from './promise_provider';
 import { Logger } from './logger';
-import { ReadConcern, ReadConcernLevel, ReadConcernLike } from './read_concern';
+import { ReadConcern, ReadConcernLevelId, ReadConcernLike } from './read_concern';
 import { BSONSerializeOptions, Document, resolveBSONOptions } from './bson';
 import type { AutoEncryptionOptions } from './deps';
 import type { CompressorName } from './cmap/wire_protocol/compression';
-import type { AuthMechanism } from './cmap/auth/defaultAuthProviders';
+import type { AuthMechanismId } from './cmap/auth/defaultAuthProviders';
 import type { Topology } from './sdam/topology';
 import type { ClientSession, ClientSessionOptions } from './sessions';
 import type { OperationParent } from './operations/command';
@@ -24,15 +24,15 @@ import type { MongoCredentials } from './cmap/auth/mongo_credentials';
 import { parseOptions } from './connection_string';
 
 /** @public */
-export const LogLevelEnum = {
+export const LogLevel = {
   error: 'error',
   warn: 'warn',
   info: 'info',
   debug: 'debug'
 } as const;
 
 /** @public */
-export type LogLevel = typeof LogLevelEnum[keyof typeof LogLevelEnum];
+export type LogLevelId = typeof LogLevel[keyof typeof LogLevel];
 
 /** @public */
 export interface DriverInfo {
@@ -99,17 +99,17 @@ export interface MongoURIOptions extends Pick<WriteConcernOptions, 'journal' | '
   /** The maximum time in milliseconds that a thread can wait for a connection to become available. */
   waitQueueTimeoutMS?: number;
   /** The level of isolation */
-  readConcernLevel?: ReadConcernLevel;
+  readConcernLevel?: ReadConcernLevelId;
   /** Specifies the read preferences for this connection */
-  readPreference?: ReadPreferenceMode | ReadPreference;
+  readPreference?: ReadPreferenceModeId | ReadPreference;
   /** Specifies, in seconds, how stale a secondary can be before the client stops using it for read operations. */
   maxStalenessSeconds?: number;
   /** Specifies the tags document as a comma-separated list of colon-separated key-value pairs.  */
   readPreferenceTags?: TagSet[];
   /** Specify the database name associated with the user’s credentials. */
   authSource?: string;
   /** Specify the authentication mechanism that MongoDB will use to authenticate the connection. */
-  authMechanism?: AuthMechanism;
+  authMechanism?: AuthMechanismId;
   /** Specify properties for the specified authMechanism as a comma-separated list of colon-separated key-value pairs. */
   authMechanismProperties?: {
     SERVICE_NAME?: string;
@@ -181,7 +181,7 @@ export interface MongoClientOptions
   /** Specify a read concern for the collection (only MongoDB 3.2 or higher supported) */
   readConcern?: ReadConcernLike;
   /** The logging level */
-  loggerLevel?: LogLevel;
+  loggerLevel?: LogLevelId;
   /** Custom logger object */
   logger?: Logger;
   /** The auth settings for when connection to server. */

src/operations/connect.ts

@@ -12,7 +12,7 @@ import * as BSON from '../bson';
 import type { Document } from '../bson';
 import type { MongoClient } from '../mongo_client';
 import { ConnectionOptions, Connection } from '../cmap/connection';
-import type { AuthMechanism } from '../cmap/auth/defaultAuthProviders';
+import type { AuthMechanismId } from '../cmap/auth/defaultAuthProviders';
 import { Server } from '../sdam/server';
 
 const VALID_AUTH_MECHANISMS = new Set([
@@ -444,7 +444,7 @@ export interface GenerateCredentialsOptions {
   authSource: string;
   authdb: string;
   dbName: string;
-  authMechanism: AuthMechanism;
+  authMechanism: AuthMechanismId;
   authMechanismProperties: Document;
 }
 
@@ -462,15 +462,15 @@ function generateCredentials(
 
   // authMechanism
   const authMechanismRaw = options.authMechanism || 'DEFAULT';
-  const authMechanism = authMechanismRaw.toUpperCase();
+  const mechanism = authMechanismRaw.toUpperCase() as AuthMechanismId;
   const mechanismProperties = options.authMechanismProperties;
 
-  if (!VALID_AUTH_MECHANISMS.has(authMechanism)) {
-    throw new MongoError(`authentication mechanism ${authMechanism} not supported`);
+  if (!VALID_AUTH_MECHANISMS.has(mechanism)) {
+    throw new MongoError(`authentication mechanism ${mechanism} not supported`);
   }
 
   return new MongoCredentials({
-    mechanism: authMechanism as AuthMechanism,
+    mechanism,
     mechanismProperties,
     source,
     username,

src/read_concern.ts

@@ -1,5 +1,5 @@
 /** @public */
-export const ReadConcernLevelEnum = {
+export const ReadConcernLevel = {
   local: 'local',
   majority: 'majority',
   linearizable: 'linearizable',
@@ -8,10 +8,10 @@ export const ReadConcernLevelEnum = {
 } as const;
 
 /** @public */
-export type ReadConcernLevel = keyof typeof ReadConcernLevelEnum;
+export type ReadConcernLevelId = keyof typeof ReadConcernLevel;
 
 /** @public */
-export type ReadConcernLike = ReadConcern | { level: ReadConcernLevel } | ReadConcernLevel;
+export type ReadConcernLike = ReadConcern | { level: ReadConcernLevelId } | ReadConcernLevelId;
 
 /**
  * The MongoDB ReadConcern, which allows for control of the consistency and isolation properties
@@ -21,17 +21,17 @@ export type ReadConcernLike = ReadConcern | { level: ReadConcernLevel } | ReadCo
  * @see https://docs.mongodb.com/manual/reference/read-concern/index.html
  */
 export class ReadConcern {
-  level: ReadConcernLevel | string;
+  level: ReadConcernLevelId | string;
 
   /** Constructs a ReadConcern from the read concern level.*/
-  constructor(level: ReadConcernLevel) {
+  constructor(level: ReadConcernLevelId) {
     /**
      * A spec test exists that allows level to be any string.
      * "invalid readConcern with out stage"
      * @see ./test/spec/crud/v2/aggregate-out-readConcern.json
      * @see https://github.com/mongodb/specifications/blob/master/source/read-write-concern/read-write-concern.rst#unknown-levels-and-additional-options-for-string-based-readconcerns
      */
-    this.level = ReadConcernLevelEnum[level] || level;
+    this.level = ReadConcernLevel[level] ?? level;
   }
 
   /**
@@ -41,7 +41,7 @@ export class ReadConcern {
    */
   static fromOptions(options?: {
     readConcern?: ReadConcernLike;
-    level?: ReadConcernLevel;
+    level?: ReadConcernLevelId;
   }): ReadConcern | undefined {
     if (options == null) {
       return;
@@ -64,18 +64,18 @@ export class ReadConcern {
   }
 
   static get MAJORITY(): 'majority' {
-    return ReadConcernLevelEnum.majority;
+    return ReadConcernLevel.majority;
   }
 
   static get AVAILABLE(): 'available' {
-    return ReadConcernLevelEnum.available;
+    return ReadConcernLevel.available;
   }
 
   static get LINEARIZABLE(): 'linearizable' {
-    return ReadConcernLevelEnum.linearizable;
+    return ReadConcernLevel.linearizable;
   }
 
   static get SNAPSHOT(): 'snapshot' {
-    return ReadConcernLevelEnum.snapshot;
+    return ReadConcernLevel.snapshot;
   }
 }