mongodb 6.3.0 → 6.4.0

package/src/cmap/connect.ts

@@ -16,16 +16,9 @@ import {
   MongoRuntimeError,
   needsRetryableWriteLabel
 } from '../error';
-import { type Callback, HostAddress, ns } from '../utils';
-import { AuthContext, type AuthProvider } from './auth/auth_provider';
-import { GSSAPI } from './auth/gssapi';
-import { MongoCR } from './auth/mongocr';
-import { MongoDBAWS } from './auth/mongodb_aws';
-import { MongoDBOIDC } from './auth/mongodb_oidc';
-import { Plain } from './auth/plain';
+import { HostAddress, ns, promiseWithResolvers } from '../utils';
+import { AuthContext } from './auth/auth_provider';
 import { AuthMechanism } from './auth/providers';
-import { ScramSHA1, ScramSHA256 } from './auth/scram';
-import { X509 } from './auth/x509';
 import {
   type CommandOptions,
   Connection,
@@ -40,42 +33,29 @@ import {
   MIN_SUPPORTED_WIRE_VERSION
 } from './wire_protocol/constants';
 
-/** @internal */
-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_OIDC, new MongoDBOIDC()],
-  [AuthMechanism.MONGODB_PLAIN, new Plain()],
-  [AuthMechanism.MONGODB_SCRAM_SHA1, new ScramSHA1()],
-  [AuthMechanism.MONGODB_SCRAM_SHA256, new ScramSHA256()],
-  [AuthMechanism.MONGODB_X509, new X509()]
-]);
-
 /** @public */
 export type Stream = Socket | TLSSocket;
 
-export function connect(options: ConnectionOptions, callback: Callback<Connection>): void {
-  makeConnection({ ...options, existingSocket: undefined }, (err, socket) => {
-    if (err || !socket) {
-      return callback(err);
-    }
-
-    let ConnectionType = options.connectionType ?? Connection;
-    if (options.autoEncrypter) {
-      ConnectionType = CryptoConnection;
-    }
+export async function connect(options: ConnectionOptions): Promise<Connection> {
+  let connection: Connection | null = null;
+  try {
+    const socket = await makeSocket(options);
+    connection = makeConnection(options, socket);
+    await performInitialHandshake(connection, options);
+    return connection;
+  } catch (error) {
+    connection?.destroy({ force: false });
+    throw error;
+  }
+}
 
-    const connection = new ConnectionType(socket, options);
+export function makeConnection(options: ConnectionOptions, socket: Stream): Connection {
+  let ConnectionType = options.connectionType ?? Connection;
+  if (options.autoEncrypter) {
+    ConnectionType = CryptoConnection;
+  }
 
-    performInitialHandshake(connection, options).then(
-      () => callback(undefined, connection),
-      error => {
-        connection.destroy({ force: false });
-        callback(error);
-      }
-    );
-  });
+  return new ConnectionType(socket, options);
 }
 
 function checkSupportedServer(hello: Document, options: ConnectionOptions) {
@@ -103,7 +83,7 @@ function checkSupportedServer(hello: Document, options: ConnectionOptions) {
   return new MongoCompatibilityError(message);
 }
 
-async function performInitialHandshake(
+export async function performInitialHandshake(
   conn: Connection,
   options: ConnectionOptions
 ): Promise<void> {
@@ -112,7 +92,7 @@ async function performInitialHandshake(
   if (credentials) {
     if (
       !(credentials.mechanism === AuthMechanism.MONGODB_DEFAULT) &&
-      !AUTH_PROVIDERS.get(credentials.mechanism)
+      !options.authProviders.getOrCreateProvider(credentials.mechanism)
     ) {
       throw new MongoInvalidArgumentError(`AuthMechanism '${credentials.mechanism}' not supported`);
     }
@@ -131,7 +111,7 @@ async function performInitialHandshake(
   }
 
   const start = new Date().getTime();
-  const response = await conn.commandAsync(ns('admin.$cmd'), handshakeDoc, handshakeOptions);
+  const response = await conn.command(ns('admin.$cmd'), handshakeDoc, handshakeOptions);
 
   if (!('isWritablePrimary' in response)) {
     // Provide hello-style response document.
@@ -167,7 +147,7 @@ async function performInitialHandshake(
     authContext.response = response;
 
     const resolvedCredentials = credentials.resolveAuthMechanism(response);
-    const provider = AUTH_PROVIDERS.get(resolvedCredentials.mechanism);
+    const provider = options.authProviders.getOrCreateProvider(resolvedCredentials.mechanism);
     if (!provider) {
       throw new MongoInvalidArgumentError(
         `No AuthProvider for ${resolvedCredentials.mechanism} defined.`
@@ -186,8 +166,16 @@ async function performInitialHandshake(
       throw error;
     }
   }
+
+  // Connection establishment is socket creation (tcp handshake, tls handshake, MongoDB handshake (saslStart, saslContinue))
+  // Once connection is established, command logging can log events (if enabled)
+  conn.established = true;
 }
 
+/**
+ * HandshakeDocument used during authentication.
+ * @internal
+ */
 export interface HandshakeDocument extends Document {
   /**
    * @deprecated Use hello instead
@@ -229,7 +217,9 @@ export async function prepareHandshakeDocument(
     if (credentials.mechanism === AuthMechanism.MONGODB_DEFAULT && credentials.username) {
       handshakeDoc.saslSupportedMechs = `${credentials.source}.${credentials.username}`;
 
-      const provider = AUTH_PROVIDERS.get(AuthMechanism.MONGODB_SCRAM_SHA256);
+      const provider = authContext.options.authProviders.getOrCreateProvider(
+        AuthMechanism.MONGODB_SCRAM_SHA256
+      );
       if (!provider) {
         // This auth mechanism is always present.
         throw new MongoInvalidArgumentError(
@@ -238,7 +228,7 @@ export async function prepareHandshakeDocument(
       }
       return provider.prepare(handshakeDoc, authContext);
     }
-    const provider = AUTH_PROVIDERS.get(credentials.mechanism);
+    const provider = authContext.options.authProviders.getOrCreateProvider(credentials.mechanism);
     if (!provider) {
       throw new MongoInvalidArgumentError(`No AuthProvider for ${credentials.mechanism} defined.`);
     }
@@ -325,11 +315,7 @@ function parseSslOptions(options: MakeConnectionOptions): TLSConnectionOpts {
   return result;
 }
 
-const SOCKET_ERROR_EVENT_LIST = ['error', 'close', 'timeout', 'parseError'] as const;
-type ErrorHandlerEventName = (typeof SOCKET_ERROR_EVENT_LIST)[number] | 'cancel';
-const SOCKET_ERROR_EVENTS = new Set(SOCKET_ERROR_EVENT_LIST);
-
-function makeConnection(options: MakeConnectionOptions, _callback: Callback<Stream>) {
+export async function makeSocket(options: MakeConnectionOptions): Promise<Stream> {
   const useTLS = options.tls ?? false;
   const noDelay = options.noDelay ?? true;
   const connectTimeoutMS = options.connectTimeoutMS ?? 30000;
@@ -337,23 +323,13 @@ function makeConnection(options: MakeConnectionOptions, _callback: Callback<Stre
   const existingSocket = options.existingSocket;
 
   let socket: Stream;
-  const callback: Callback<Stream> = function (err, ret) {
-    if (err && socket) {
-      socket.destroy();
-    }
-
-    _callback(err, ret);
-  };
 
   if (options.proxyHost != null) {
     // Currently, only Socks5 is supported.
-    return makeSocks5Connection(
-      {
-        ...options,
-        connectTimeoutMS // Should always be present for Socks5
-      },
-      callback
-    );
+    return makeSocks5Connection({
+      ...options,
+      connectTimeoutMS // Should always be present for Socks5
+    });
   }
 
   if (useTLS) {
@@ -375,47 +351,41 @@ function makeConnection(options: MakeConnectionOptions, _callback: Callback<Stre
   socket.setTimeout(connectTimeoutMS);
   socket.setNoDelay(noDelay);
 
-  const connectEvent = useTLS ? 'secureConnect' : 'connect';
-  let cancellationHandler: (err: Error) => void;
-  function errorHandler(eventName: ErrorHandlerEventName) {
-    return (err: Error) => {
-      SOCKET_ERROR_EVENTS.forEach(event => socket.removeAllListeners(event));
-      if (cancellationHandler && options.cancellationToken) {
-        options.cancellationToken.removeListener('cancel', cancellationHandler);
-      }
-
-      socket.removeListener(connectEvent, connectHandler);
-      callback(connectionFailureError(eventName, err));
-    };
-  }
+  let cancellationHandler: ((err: Error) => void) | null = null;
 
-  function connectHandler() {
-    SOCKET_ERROR_EVENTS.forEach(event => socket.removeAllListeners(event));
-    if (cancellationHandler && options.cancellationToken) {
-      options.cancellationToken.removeListener('cancel', cancellationHandler);
+  const { promise: connectedSocket, resolve, reject } = promiseWithResolvers<Stream>();
+  if (existingSocket) {
+    resolve(socket);
+  } else {
+    const connectEvent = useTLS ? 'secureConnect' : 'connect';
+    socket
+      .once(connectEvent, () => resolve(socket))
+      .once('error', error => reject(connectionFailureError('error', error)))
+      .once('timeout', () => reject(connectionFailureError('timeout')))
+      .once('close', () => reject(connectionFailureError('close')));
+
+    if (options.cancellationToken != null) {
+      cancellationHandler = () => reject(connectionFailureError('cancel'));
+      options.cancellationToken.once('cancel', cancellationHandler);
     }
+  }
 
-    if ('authorizationError' in socket) {
-      if (socket.authorizationError && rejectUnauthorized) {
-        // TODO(NODE-5192): wrap this with a MongoError subclass
-        return callback(socket.authorizationError);
-      }
+  try {
+    socket = await connectedSocket;
+    return socket;
+  } catch (error) {
+    socket.destroy();
+    if ('authorizationError' in socket && socket.authorizationError != null && rejectUnauthorized) {
+      // TODO(NODE-5192): wrap this with a MongoError subclass
+      throw socket.authorizationError;
     }
-
+    throw error;
+  } finally {
     socket.setTimeout(0);
-    callback(undefined, socket);
-  }
-
-  SOCKET_ERROR_EVENTS.forEach(event => socket.once(event, errorHandler(event)));
-  if (options.cancellationToken) {
-    cancellationHandler = errorHandler('cancel');
-    options.cancellationToken.once('cancel', cancellationHandler);
-  }
-
-  if (existingSocket) {
-    process.nextTick(connectHandler);
-  } else {
-    socket.once(connectEvent, connectHandler);
+    socket.removeAllListeners();
+    if (cancellationHandler != null) {
+      options.cancellationToken?.removeListener('cancel', cancellationHandler);
+    }
   }
 }
 
@@ -431,78 +401,68 @@ function loadSocks() {
   return socks;
 }
 
-function makeSocks5Connection(options: MakeConnectionOptions, callback: Callback<Stream>) {
+async function makeSocks5Connection(options: MakeConnectionOptions): Promise<Stream> {
   const hostAddress = HostAddress.fromHostPort(
     options.proxyHost ?? '', // proxyHost is guaranteed to set here
     options.proxyPort ?? 1080
   );
 
   // First, connect to the proxy server itself:
-  makeConnection(
-    {
-      ...options,
-      hostAddress,
-      tls: false,
-      proxyHost: undefined
-    },
-    (err, rawSocket) => {
-      if (err || !rawSocket) {
-        return callback(err);
-      }
+  const rawSocket = await makeSocket({
+    ...options,
+    hostAddress,
+    tls: false,
+    proxyHost: undefined
+  });
 
-      const destination = parseConnectOptions(options) as net.TcpNetConnectOpts;
-      if (typeof destination.host !== 'string' || typeof destination.port !== 'number') {
-        return callback(
-          new MongoInvalidArgumentError('Can only make Socks5 connections to TCP hosts')
-        );
-      }
+  const destination = parseConnectOptions(options) as net.TcpNetConnectOpts;
+  if (typeof destination.host !== 'string' || typeof destination.port !== 'number') {
+    throw new MongoInvalidArgumentError('Can only make Socks5 connections to TCP hosts');
+  }
 
-      try {
-        socks ??= loadSocks();
-      } catch (error) {
-        return callback(error);
+  socks ??= loadSocks();
+
+  try {
+    // Then, establish the Socks5 proxy connection:
+    const { socket } = await socks.SocksClient.createConnection({
+      existing_socket: rawSocket,
+      timeout: options.connectTimeoutMS,
+      command: 'connect',
+      destination: {
+        host: destination.host,
+        port: destination.port
+      },
+      proxy: {
+        // host and port are ignored because we pass existing_socket
+        host: 'iLoveJavaScript',
+        port: 0,
+        type: 5,
+        userId: options.proxyUsername || undefined,
+        password: options.proxyPassword || undefined
       }
+    });
 
-      // Then, establish the Socks5 proxy connection:
-      socks.SocksClient.createConnection({
-        existing_socket: rawSocket,
-        timeout: options.connectTimeoutMS,
-        command: 'connect',
-        destination: {
-          host: destination.host,
-          port: destination.port
-        },
-        proxy: {
-          // host and port are ignored because we pass existing_socket
-          host: 'iLoveJavaScript',
-          port: 0,
-          type: 5,
-          userId: options.proxyUsername || undefined,
-          password: options.proxyPassword || undefined
-        }
-      }).then(
-        ({ socket }) => {
-          // Finally, now treat the resulting duplex stream as the
-          // socket over which we send and receive wire protocol messages:
-          makeConnection(
-            {
-              ...options,
-              existingSocket: socket,
-              proxyHost: undefined
-            },
-            callback
-          );
-        },
-        error => callback(connectionFailureError('error', error))
-      );
-    }
-  );
+    // Finally, now treat the resulting duplex stream as the
+    // socket over which we send and receive wire protocol messages:
+    return await makeSocket({
+      ...options,
+      existingSocket: socket,
+      proxyHost: undefined
+    });
+  } catch (error) {
+    throw connectionFailureError('error', error);
+  }
 }
 
-function connectionFailureError(type: ErrorHandlerEventName, err: Error) {
+function connectionFailureError(type: 'error', cause: Error): MongoNetworkError;
+function connectionFailureError(type: 'close' | 'timeout' | 'cancel'): MongoNetworkError;
+function connectionFailureError(
+  type: 'error' | 'close' | 'timeout' | 'cancel',
+  cause?: Error
+): MongoNetworkError {
   switch (type) {
     case 'error':
-      return new MongoNetworkError(MongoError.buildErrorMessage(err), { cause: err });
+      return new MongoNetworkError(MongoError.buildErrorMessage(cause), { cause });
     case 'timeout':
       return new MongoNetworkTimeoutError('connection timed out');
     case 'close':