mongodb 4.2.2 → 4.3.0

package/src/sdam/server_description.ts

@@ -1,8 +1,8 @@
-import { arrayStrictEqual, errorStrictEqual, now, HostAddress } from '../utils';
-import { ServerType } from './common';
-import { ObjectId, Long, Document } from '../bson';
-import type { ClusterTime } from './common';
+import { Document, Long, ObjectId } from '../bson';
 import type { MongoError } from '../error';
+import { arrayStrictEqual, errorStrictEqual, HostAddress, now } from '../utils';
+import type { ClusterTime } from './common';
+import { ServerType } from './common';
 
 const WRITABLE_SERVER_TYPES = new Set<ServerType>([
   ServerType.RSPrimary,

package/src/sdam/server_selection.ts

@@ -1,8 +1,8 @@
-import { ServerType, TopologyType } from './common';
-import { ReadPreference } from '../read_preference';
 import { MongoCompatibilityError, MongoInvalidArgumentError } from '../error';
-import type { TopologyDescription } from './topology_description';
+import { ReadPreference } from '../read_preference';
+import { ServerType, TopologyType } from './common';
 import type { ServerDescription, TagSet } from './server_description';
+import type { TopologyDescription } from './topology_description';
 
 // max staleness constants
 const IDLE_WRITE_PERIOD = 10000;

package/src/sdam/srv_polling.ts

@@ -1,8 +1,9 @@
 import * as dns from 'dns';
+
+import { MongoRuntimeError } from '../error';
 import { Logger, LoggerOptions } from '../logger';
-import { HostAddress } from '../utils';
 import { TypedEventEmitter } from '../mongo_types';
-import { MongoRuntimeError } from '../error';
+import { HostAddress } from '../utils';
 
 /**
  * Determines whether a provided address matches the provided parent domain in order

package/src/sdam/topology.ts

@@ -1,88 +1,83 @@
 import Denque = require('denque');
-import { ReadPreference, ReadPreferenceLike } from '../read_preference';
-import { compareTopologyVersion, ServerDescription } from './server_description';
-import { TopologyDescription } from './topology_description';
-import { Server, ServerEvents, ServerOptions } from './server';
+import type { BSONSerializeOptions, Document } from '../bson';
+import { deserialize, serialize } from '../bson';
+import type { MongoCredentials } from '../cmap/auth/mongo_credentials';
+import type { ConnectionEvents, DestroyOptions } from '../cmap/connection';
+import type { CloseOptions, ConnectionPoolEvents } from '../cmap/connection_pool';
+import { DEFAULT_OPTIONS } from '../connection_string';
 import {
-  ClientSession,
-  ServerSessionPool,
-  ServerSessionId,
-  ClientSessionOptions
-} from '../sessions';
-import { SrvPoller, SrvPollingEvent } from './srv_polling';
-import { CMAP_EVENTS, ConnectionPoolEvents } from '../cmap/connection_pool';
+  CLOSE,
+  CONNECT,
+  ERROR,
+  LOCAL_SERVER_EVENTS,
+  OPEN,
+  SERVER_CLOSED,
+  SERVER_DESCRIPTION_CHANGED,
+  SERVER_OPENING,
+  SERVER_RELAY_EVENTS,
+  TIMEOUT,
+  TOPOLOGY_CLOSED,
+  TOPOLOGY_DESCRIPTION_CHANGED,
+  TOPOLOGY_OPENING
+} from '../constants';
 import {
-  MongoServerSelectionError,
   MongoCompatibilityError,
   MongoDriverError,
-  MongoTopologyClosedError,
-  MongoRuntimeError
+  MongoRuntimeError,
+  MongoServerSelectionError,
+  MongoTopologyClosedError
 } from '../error';
-import { readPreferenceServerSelector, ServerSelector } from './server_selection';
+import type { MongoOptions, ServerApi } from '../mongo_client';
+import { TypedEventEmitter } from '../mongo_types';
+import { ReadPreference, ReadPreferenceLike } from '../read_preference';
+import {
+  ClientSession,
+  ClientSessionOptions,
+  ServerSessionId,
+  ServerSessionPool
+} from '../sessions';
+import type { Transaction } from '../transactions';
 import {
-  makeStateMachine,
-  eachAsync,
-  ClientMetadata,
   Callback,
-  HostAddress,
-  ns,
+  ClientMetadata,
+  eachAsync,
   emitWarning,
   EventEmitterWithState,
+  HostAddress,
+  makeStateMachine,
+  ns,
   shuffle
 } from '../utils';
 import {
-  TopologyType,
-  ServerType,
-  ClusterTime,
-  TimerQueue,
   _advanceClusterTime,
-  drainTimerQueue,
   clearAndRemoveTimerFrom,
+  ClusterTime,
+  drainTimerQueue,
+  ServerType,
   STATE_CLOSED,
   STATE_CLOSING,
+  STATE_CONNECTED,
   STATE_CONNECTING,
-  STATE_CONNECTED
+  TimerQueue,
+  TopologyType
 } from './common';
 import {
-  ServerOpeningEvent,
   ServerClosedEvent,
   ServerDescriptionChangedEvent,
-  TopologyOpeningEvent,
+  ServerOpeningEvent,
   TopologyClosedEvent,
-  TopologyDescriptionChangedEvent
+  TopologyDescriptionChangedEvent,
+  TopologyOpeningEvent
 } from './events';
-import type { Document, BSONSerializeOptions } from '../bson';
-import type { MongoCredentials } from '../cmap/auth/mongo_credentials';
-import type { Transaction } from '../transactions';
-import type { CloseOptions } from '../cmap/connection_pool';
-import { DestroyOptions, Connection, ConnectionEvents } from '../cmap/connection';
-import type { MongoOptions, ServerApi } from '../mongo_client';
-import { DEFAULT_OPTIONS } from '../connection_string';
-import { serialize, deserialize } from '../bson';
-import { TypedEventEmitter } from '../mongo_types';
+import { Server, ServerEvents, ServerOptions } from './server';
+import { compareTopologyVersion, ServerDescription } from './server_description';
+import { readPreferenceServerSelector, ServerSelector } from './server_selection';
+import { SrvPoller, SrvPollingEvent } from './srv_polling';
+import { TopologyDescription } from './topology_description';
 
 // Global state
 let globalTopologyCounter = 0;
 
-// events that we relay to the `Topology`
-const SERVER_RELAY_EVENTS = [
-  Server.SERVER_HEARTBEAT_STARTED,
-  Server.SERVER_HEARTBEAT_SUCCEEDED,
-  Server.SERVER_HEARTBEAT_FAILED,
-  Connection.COMMAND_STARTED,
-  Connection.COMMAND_SUCCEEDED,
-  Connection.COMMAND_FAILED,
-  ...CMAP_EVENTS
-];
-
-// all events we listen to from `Server` instances
-const LOCAL_SERVER_EVENTS = [
-  Server.CONNECT,
-  Server.DESCRIPTION_RECEIVED,
-  Server.CLOSED,
-  Server.ENDED
-];
-
 const stateTransition = makeStateMachine({
   [STATE_CLOSED]: [STATE_CLOSED, STATE_CONNECTING],
   [STATE_CONNECTING]: [STATE_CONNECTING, STATE_CLOSING, STATE_CONNECTED, STATE_CLOSED],
@@ -208,27 +203,27 @@ export class Topology extends TypedEventEmitter<TopologyEvents> {
   _type?: string;
 
   /** @event */
-  static readonly SERVER_OPENING = 'serverOpening' as const;
+  static readonly SERVER_OPENING = SERVER_OPENING;
   /** @event */
-  static readonly SERVER_CLOSED = 'serverClosed' as const;
+  static readonly SERVER_CLOSED = SERVER_CLOSED;
   /** @event */
-  static readonly SERVER_DESCRIPTION_CHANGED = 'serverDescriptionChanged' as const;
+  static readonly SERVER_DESCRIPTION_CHANGED = SERVER_DESCRIPTION_CHANGED;
   /** @event */
-  static readonly TOPOLOGY_OPENING = 'topologyOpening' as const;
+  static readonly TOPOLOGY_OPENING = TOPOLOGY_OPENING;
   /** @event */
-  static readonly TOPOLOGY_CLOSED = 'topologyClosed' as const;
+  static readonly TOPOLOGY_CLOSED = TOPOLOGY_CLOSED;
   /** @event */
-  static readonly TOPOLOGY_DESCRIPTION_CHANGED = 'topologyDescriptionChanged' as const;
+  static readonly TOPOLOGY_DESCRIPTION_CHANGED = TOPOLOGY_DESCRIPTION_CHANGED;
   /** @event */
-  static readonly ERROR = 'error' as const;
+  static readonly ERROR = ERROR;
   /** @event */
-  static readonly OPEN = 'open' as const;
+  static readonly OPEN = OPEN;
   /** @event */
-  static readonly CONNECT = 'connect' as const;
+  static readonly CONNECT = CONNECT;
   /** @event */
-  static readonly CLOSE = 'close' as const;
+  static readonly CLOSE = CLOSE;
   /** @event */
-  static readonly TIMEOUT = 'timeout' as const;
+  static readonly TIMEOUT = TIMEOUT;
 
   /**
    * @internal
@@ -827,19 +822,6 @@ export class Topology extends TypedEventEmitter<TopologyEvents> {
   }
 }
 
-/** @public */
-export const TOPOLOGY_EVENTS = [
-  Topology.SERVER_OPENING,
-  Topology.SERVER_CLOSED,
-  Topology.SERVER_DESCRIPTION_CHANGED,
-  Topology.TOPOLOGY_OPENING,
-  Topology.TOPOLOGY_CLOSED,
-  Topology.TOPOLOGY_DESCRIPTION_CHANGED,
-  Topology.ERROR,
-  Topology.TIMEOUT,
-  Topology.CLOSE
-];
-
 /** Destroys a server, and removes all event listeners from the instance */
 function destroyServer(
   server: Server,

package/src/sdam/topology_description.ts

@@ -1,10 +1,10 @@
-import { ServerDescription } from './server_description';
+import type { Document, ObjectId } from '../bson';
 import * as WIRE_CONSTANTS from '../cmap/wire_protocol/constants';
-import { TopologyType, ServerType } from './common';
-import type { ObjectId, Document } from '../bson';
-import type { SrvPollingEvent } from './srv_polling';
 import { MongoError, MongoRuntimeError } from '../error';
 import { shuffle } from '../utils';
+import { ServerType, TopologyType } from './common';
+import { ServerDescription } from './server_description';
+import type { SrvPollingEvent } from './srv_polling';
 
 // constants related to compatibility checks
 const MIN_SUPPORTED_SERVER_VERSION = WIRE_CONSTANTS.MIN_SUPPORTED_SERVER_VERSION;

package/src/sessions.ts

@@ -1,46 +1,47 @@
-import { PromiseProvider } from './promise_provider';
-import { Binary, Long, Timestamp, Document } from './bson';
-import { ReadPreference } from './read_preference';
-import { isTransactionCommand, TxnState, Transaction, TransactionOptions } from './transactions';
-import { _advanceClusterTime, ClusterTime, TopologyType } from './sdam/common';
+import { Binary, Document, Long, Timestamp } from './bson';
+import type { CommandOptions, Connection } from './cmap/connection';
+import { ConnectionPoolMetrics } from './cmap/metrics';
 import { isSharded } from './cmap/wire_protocol/shared';
+import { PINNED, UNPINNED } from './constants';
+import type { AbstractCursor } from './cursor/abstract_cursor';
 import {
-  MongoError,
-  MongoInvalidArgumentError,
-  isRetryableError,
+  AnyError,
   isRetryableEndTransactionError,
+  isRetryableError,
+  MongoAPIError,
   MongoCompatibilityError,
-  MongoNetworkError,
-  MongoWriteConcernError,
   MONGODB_ERROR_CODES,
-  MongoServerError,
   MongoDriverError,
-  MongoAPIError,
-  AnyError,
+  MongoError,
   MongoExpiredSessionError,
+  MongoInvalidArgumentError,
+  MongoNetworkError,
+  MongoRuntimeError,
+  MongoServerError,
   MongoTransactionError,
-  MongoRuntimeError
+  MongoWriteConcernError
 } from './error';
+import type { MongoOptions } from './mongo_client';
+import { TypedEventEmitter } from './mongo_types';
+import { executeOperation } from './operations/execute_operation';
+import { RunAdminCommandOperation } from './operations/run_command';
+import { PromiseProvider } from './promise_provider';
+import { ReadConcernLevel } from './read_concern';
+import { ReadPreference } from './read_preference';
+import { _advanceClusterTime, ClusterTime, TopologyType } from './sdam/common';
+import type { Topology } from './sdam/topology';
+import { isTransactionCommand, Transaction, TransactionOptions, TxnState } from './transactions';
 import {
-  now,
   calculateDurationInMs,
   Callback,
+  commandSupportsReadConcern,
   isPromiseLike,
-  uuidV4,
   maxWireVersion,
-  maybePromise
+  maybePromise,
+  now,
+  uuidV4
 } from './utils';
-import type { Topology } from './sdam/topology';
-import type { MongoOptions } from './mongo_client';
-import { executeOperation } from './operations/execute_operation';
-import { RunAdminCommandOperation } from './operations/run_command';
-import type { AbstractCursor } from './cursor/abstract_cursor';
-import type { CommandOptions } from './cmap/connection';
-import { Connection } from './cmap/connection';
-import { ConnectionPoolMetrics } from './cmap/metrics';
 import type { WriteConcern } from './write_concern';
-import { TypedEventEmitter } from './mongo_types';
-import { ReadConcernLevel } from './read_concern';
 
 const minWireVersionForShardedTransactions = 8;
 
@@ -225,7 +226,7 @@ export class ClientSession extends TypedEventEmitter<ClientSessionEvents> {
 
     this[kPinnedConnection] = conn;
     conn.emit(
-      Connection.PINNED,
+      PINNED,
       this.inTransaction() ? ConnectionPoolMetrics.TXN : ConnectionPoolMetrics.CURSOR
     );
   }
@@ -520,7 +521,7 @@ export function maybeClearPinnedConnection(
     if (options?.error == null || options?.force) {
       loadBalancer.s.pool.checkIn(conn);
       conn.emit(
-        Connection.UNPINNED,
+        UNPINNED,
         session.transaction.state !== TxnState.NO_TRANSACTION
           ? ConnectionPoolMetrics.TXN
           : ConnectionPoolMetrics.CURSOR
@@ -929,25 +930,6 @@ export class ServerSessionPool {
   }
 }
 
-// TODO: this should be codified in command construction
-// @see https://github.com/mongodb/specifications/blob/master/source/read-write-concern/read-write-concern.rst#read-concern
-export function commandSupportsReadConcern(command: Document, options?: Document): boolean {
-  if (command.aggregate || command.count || command.distinct || command.find || command.geoNear) {
-    return true;
-  }
-
-  if (
-    command.mapReduce &&
-    options &&
-    options.out &&
-    (options.out.inline === 1 || options.out === 'inline')
-  ) {
-    return true;
-  }
-
-  return false;
-}
-
 /**
  * Optionally decorate a command with sessions specific keys
  *

package/src/transactions.ts

@@ -1,10 +1,10 @@
-import { ReadPreference } from './read_preference';
+import type { Document } from './bson';
 import { MongoRuntimeError, MongoTransactionError } from './error';
+import type { CommandOperationOptions } from './operations/command';
 import { ReadConcern, ReadConcernLike } from './read_concern';
-import { WriteConcern } from './write_concern';
+import { ReadPreference } from './read_preference';
 import type { Server } from './sdam/server';
-import type { CommandOperationOptions } from './operations/command';
-import type { Document } from './bson';
+import { WriteConcern } from './write_concern';
 
 /** @internal */
 export const TxnState = Object.freeze({

package/src/utils.ts

@@ -1,34 +1,36 @@
-import * as os from 'os';
 import * as crypto from 'crypto';
-import { PromiseProvider } from './promise_provider';
+import type { SrvRecord } from 'dns';
+import * as os from 'os';
+import { URL } from 'url';
+
+import { Document, ObjectId, resolveBSONOptions } from './bson';
+import type { Connection } from './cmap/connection';
+import { MAX_SUPPORTED_WIRE_VERSION } from './cmap/wire_protocol/constants';
+import type { Collection } from './collection';
+import { LEGACY_HELLO_COMMAND } from './constants';
+import type { Db } from './db';
 import {
   AnyError,
-  MongoParseError,
-  MongoRuntimeError,
   MongoCompatibilityError,
-  MongoNotConnectedError,
+  MongoExpiredSessionError,
   MongoInvalidArgumentError,
-  MongoExpiredSessionError
+  MongoNotConnectedError,
+  MongoParseError,
+  MongoRuntimeError
 } from './error';
-import { WriteConcern, WriteConcernOptions, W } from './write_concern';
-import type { Server } from './sdam/server';
-import type { Topology } from './sdam/topology';
-import { ServerType } from './sdam/common';
-import type { Db } from './db';
-import type { Collection } from './collection';
-import type { OperationOptions, Hint } from './operations/operation';
-import type { ClientSession } from './sessions';
-import { ReadConcern } from './read_concern';
-import type { Connection } from './cmap/connection';
-import { Document, ObjectId, resolveBSONOptions } from './bson';
-import type { IndexSpecification, IndexDirection } from './operations/indexes';
 import type { Explain } from './explain';
 import type { MongoClient } from './mongo_client';
 import type { CommandOperationOptions, OperationParent } from './operations/command';
+import type { IndexDirection, IndexSpecification } from './operations/indexes';
+import type { Hint, OperationOptions } from './operations/operation';
+import { PromiseProvider } from './promise_provider';
+import { ReadConcern } from './read_concern';
 import { ReadPreference } from './read_preference';
-import { URL } from 'url';
-import { MAX_SUPPORTED_WIRE_VERSION } from './cmap/wire_protocol/constants';
-import type { SrvRecord } from 'dns';
+import { ServerType } from './sdam/common';
+import type { Server } from './sdam/server';
+import type { Topology } from './sdam/topology';
+import type { ClientSession } from './sessions';
+import { W, WriteConcern, WriteConcernOptions } from './write_concern';
 
 /**
  * MongoDB Driver style callback
@@ -1096,6 +1098,14 @@ export function isSuperset(set: Set<any> | any[], subset: Set<any> | any[]): boo
   return true;
 }
 
+/**
+ * Checks if the document is a Hello request
+ * @internal
+ */
+export function isHello(doc: Document): boolean {
+  return doc[LEGACY_HELLO_COMMAND] || doc.hello ? true : false;
+}
+
 /** Returns the items that are uniquely in setA */
 export function setDifference<T>(setA: Iterable<T>, setB: Iterable<T>): Set<T> {
   const difference = new Set<T>(setA);
@@ -1346,8 +1356,15 @@ export class HostAddress {
     return new HostAddress(s);
   }
 
+  static fromHostPort(host: string, port: number): HostAddress {
+    if (host.includes(':')) {
+      host = `[${host}]`; // IPv6 address
+    }
+    return HostAddress.fromString(`${host}:${port}`);
+  }
+
   static fromSrvRecord({ name, port }: SrvRecord): HostAddress {
-    return HostAddress.fromString(`${name}:${port}`);
+    return HostAddress.fromHostPort(name, port);
   }
 }
 
@@ -1449,3 +1466,22 @@ export function shuffle<T>(sequence: Iterable<T>, limit = 0): Array<T> {
 
   return limit % items.length === 0 ? items : items.slice(lowerBound);
 }
+
+// TODO: this should be codified in command construction
+// @see https://github.com/mongodb/specifications/blob/master/source/read-write-concern/read-write-concern.rst#read-concern
+export function commandSupportsReadConcern(command: Document, options?: Document): boolean {
+  if (command.aggregate || command.count || command.distinct || command.find || command.geoNear) {
+    return true;
+  }
+
+  if (
+    command.mapReduce &&
+    options &&
+    options.out &&
+    (options.out.inline === 1 || options.out === 'inline')
+  ) {
+    return true;
+  }
+
+  return false;
+}

package/lib/cmap/auth/defaultAuthProviders.js

@@ -1,30 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AUTH_PROVIDERS = exports.AuthMechanism = void 0;
-const mongocr_1 = require("./mongocr");
-const x509_1 = require("./x509");
-const plain_1 = require("./plain");
-const gssapi_1 = require("./gssapi");
-const scram_1 = require("./scram");
-const mongodb_aws_1 = require("./mongodb_aws");
-/** @public */
-exports.AuthMechanism = Object.freeze({
-    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'
-});
-exports.AUTH_PROVIDERS = new Map([
-    [exports.AuthMechanism.MONGODB_AWS, new mongodb_aws_1.MongoDBAWS()],
-    [exports.AuthMechanism.MONGODB_CR, new mongocr_1.MongoCR()],
-    [exports.AuthMechanism.MONGODB_GSSAPI, new gssapi_1.GSSAPI()],
-    [exports.AuthMechanism.MONGODB_PLAIN, new plain_1.Plain()],
-    [exports.AuthMechanism.MONGODB_SCRAM_SHA1, new scram_1.ScramSHA1()],
-    [exports.AuthMechanism.MONGODB_SCRAM_SHA256, new scram_1.ScramSHA256()],
-    [exports.AuthMechanism.MONGODB_X509, new x509_1.X509()]
-]);
-//# sourceMappingURL=defaultAuthProviders.js.map

package/lib/cmap/auth/defaultAuthProviders.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"defaultAuthProviders.js","sourceRoot":"","sources":["../../../src/cmap/auth/defaultAuthProviders.ts"],"names":[],"mappings":";;;AAAA,uCAAoC;AACpC,iCAA8B;AAC9B,mCAAgC;AAChC,qCAAkC;AAClC,mCAAiD;AACjD,+CAA2C;AAG3C,cAAc;AACD,QAAA,aAAa,GAAG,MAAM,CAAC,MAAM,CAAC;IACzC,WAAW,EAAE,aAAa;IAC1B,UAAU,EAAE,YAAY;IACxB,eAAe,EAAE,SAAS;IAC1B,cAAc,EAAE,QAAQ;IACxB,aAAa,EAAE,OAAO;IACtB,kBAAkB,EAAE,aAAa;IACjC,oBAAoB,EAAE,eAAe;IACrC,YAAY,EAAE,cAAc;CACpB,CAAC,CAAC;AAKC,QAAA,cAAc,GAAG,IAAI,GAAG,CAAuC;IAC1E,CAAC,qBAAa,CAAC,WAAW,EAAE,IAAI,wBAAU,EAAE,CAAC;IAC7C,CAAC,qBAAa,CAAC,UAAU,EAAE,IAAI,iBAAO,EAAE,CAAC;IACzC,CAAC,qBAAa,CAAC,cAAc,EAAE,IAAI,eAAM,EAAE,CAAC;IAC5C,CAAC,qBAAa,CAAC,aAAa,EAAE,IAAI,aAAK,EAAE,CAAC;IAC1C,CAAC,qBAAa,CAAC,kBAAkB,EAAE,IAAI,iBAAS,EAAE,CAAC;IACnD,CAAC,qBAAa,CAAC,oBAAoB,EAAE,IAAI,mBAAW,EAAE,CAAC;IACvD,CAAC,qBAAa,CAAC,YAAY,EAAE,IAAI,WAAI,EAAE,CAAC;CACzC,CAAC,CAAC"}

package/src/cmap/auth/defaultAuthProviders.ts

@@ -1,32 +0,0 @@
-import { MongoCR } from './mongocr';
-import { X509 } from './x509';
-import { Plain } from './plain';
-import { GSSAPI } from './gssapi';
-import { ScramSHA1, ScramSHA256 } from './scram';
-import { MongoDBAWS } from './mongodb_aws';
-import type { AuthProvider } from './auth_provider';
-
-/** @public */
-export const AuthMechanism = Object.freeze({
-  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 AuthMechanism[keyof typeof AuthMechanism];
-
-export 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()]
-]);