mongodb 6.3.0 → 6.4.0

package/src/connection_string.ts

@@ -23,9 +23,11 @@ import {
   ServerApiVersion
 } from './mongo_client';
 import {
+  MongoLoggableComponent,
   MongoLogger,
   type MongoLoggerEnvOptions,
-  type MongoLoggerMongoClientOptions
+  type MongoLoggerMongoClientOptions,
+  SeverityLevel
 } from './mongo_logger';
 import { ReadConcern, type ReadConcernLevel } from './read_concern';
 import { ReadPreference, type ReadPreferenceMode } from './read_preference';
@@ -1090,6 +1092,9 @@ export const OPTIONS = {
     target: 'tls',
     type: 'boolean'
   },
+  timeoutMS: {
+    type: 'uint'
+  },
   tls: {
     type: 'boolean'
   },
@@ -1243,12 +1248,53 @@ export const OPTIONS = {
    * @internal
    * TODO: NODE-5671 - remove internal flag
    */
-  mongodbLogPath: { type: 'any' },
+  mongodbLogPath: {
+    transform({ values: [value] }) {
+      if (
+        !(
+          (typeof value === 'string' && ['stderr', 'stdout'].includes(value)) ||
+          (value &&
+            typeof value === 'object' &&
+            'write' in value &&
+            typeof value.write === 'function')
+        )
+      ) {
+        throw new MongoAPIError(
+          `Option 'mongodbLogPath' must be of type 'stderr' | 'stdout' | MongoDBLogWritable`
+        );
+      }
+      return value;
+    }
+  },
   /**
    * @internal
    * TODO: NODE-5671 - remove internal flag
    */
-  mongodbLogComponentSeverities: { type: 'any' },
+  mongodbLogComponentSeverities: {
+    transform({ values: [value] }) {
+      if (typeof value !== 'object' || !value) {
+        throw new MongoAPIError(`Option 'mongodbLogComponentSeverities' must be a non-null object`);
+      }
+      for (const [k, v] of Object.entries(value)) {
+        if (typeof v !== 'string' || typeof k !== 'string') {
+          throw new MongoAPIError(
+            `User input for option 'mongodbLogComponentSeverities' object cannot include a non-string key or value`
+          );
+        }
+        if (!Object.values(MongoLoggableComponent).some(val => val === k) && k !== 'default') {
+          throw new MongoAPIError(
+            `User input for option 'mongodbLogComponentSeverities' contains invalid key: ${k}`
+          );
+        }
+        if (!Object.values(SeverityLevel).some(val => val === v)) {
+          throw new MongoAPIError(
+            `Option 'mongodbLogComponentSeverities' does not support ${v} as a value for ${k}`
+          );
+        }
+      }
+      return value;
+    }
+  },
   /**
    * @internal
    * TODO: NODE-5671 - remove internal flag

package/src/constants.ts

@@ -17,13 +17,27 @@ export const MESSAGE = 'message' as const;
 export const PINNED = 'pinned' as const;
 export const UNPINNED = 'unpinned' as const;
 export const DESCRIPTION_RECEIVED = 'descriptionReceived';
+/** @internal */
 export const SERVER_OPENING = 'serverOpening' as const;
+/** @internal */
 export const SERVER_CLOSED = 'serverClosed' as const;
+/** @internal */
 export const SERVER_DESCRIPTION_CHANGED = 'serverDescriptionChanged' as const;
+/** @internal */
 export const TOPOLOGY_OPENING = 'topologyOpening' as const;
+/** @internal */
 export const TOPOLOGY_CLOSED = 'topologyClosed' as const;
+/** @internal */
 export const TOPOLOGY_DESCRIPTION_CHANGED = 'topologyDescriptionChanged' as const;
 /** @internal */
+export const SERVER_SELECTION_STARTED = 'serverSelectionStarted' as const;
+/** @internal */
+export const SERVER_SELECTION_FAILED = 'serverSelectionFailed' as const;
+/** @internal */
+export const SERVER_SELECTION_SUCCEEDED = 'serverSelectionSucceeded' as const;
+/** @internal */
+export const WAITING_FOR_SUITABLE_SERVER = 'waitingForSuitableServer' as const;
+/** @internal */
 export const CONNECTION_POOL_CREATED = 'connectionPoolCreated' as const;
 /** @internal */
 export const CONNECTION_POOL_CLOSED = 'connectionPoolClosed' as const;
@@ -46,11 +60,17 @@ export const CONNECTION_CHECKED_OUT = 'connectionCheckedOut' as const;
 /** @internal */
 export const CONNECTION_CHECKED_IN = 'connectionCheckedIn' as const;
 export const CLUSTER_TIME_RECEIVED = 'clusterTimeReceived' as const;
+/** @internal */
 export const COMMAND_STARTED = 'commandStarted' as const;
+/** @internal */
 export const COMMAND_SUCCEEDED = 'commandSucceeded' as const;
+/** @internal */
 export const COMMAND_FAILED = 'commandFailed' as const;
+/** @internal */
 export const SERVER_HEARTBEAT_STARTED = 'serverHeartbeatStarted' as const;
+/** @internal */
 export const SERVER_HEARTBEAT_SUCCEEDED = 'serverHeartbeatSucceeded' as const;
+/** @internal */
 export const SERVER_HEARTBEAT_FAILED = 'serverHeartbeatFailed' as const;
 export const RESPONSE = 'response' as const;
 export const MORE = 'more' as const;

package/src/cursor/abstract_cursor.ts

@@ -337,7 +337,7 @@ export abstract class AbstractCursor<
       const transform = options.transform;
       const readable = new ReadableCursorStream(this);
 
-      return readable.pipe(
+      const transformedStream = readable.pipe(
         new Transform({
           objectMode: true,
           highWaterMark: 1,
@@ -351,6 +351,12 @@ export abstract class AbstractCursor<
           }
         })
       );
+
+      // Bubble errors to transformed stream, because otherwise no way
+      // to handle this error.
+      readable.on('error', err => transformedStream.emit('error', err));
+
+      return transformedStream;
     }
 
     return new ReadableCursorStream(this);

package/src/error.ts

@@ -109,8 +109,8 @@ export interface ErrorDescription extends Document {
   errInfo?: Document;
 }
 
-function isAggregateError(e: Error): e is Error & { errors: Error[] } {
-  return 'errors' in e && Array.isArray(e.errors);
+function isAggregateError(e: unknown): e is Error & { errors: Error[] } {
+  return e != null && typeof e === 'object' && 'errors' in e && Array.isArray(e.errors);
 }
 
 /**
@@ -150,7 +150,7 @@ export class MongoError extends Error {
   }
 
   /** @internal */
-  static buildErrorMessage(e: Error | string): string {
+  static buildErrorMessage(e: unknown): string {
     if (typeof e === 'string') {
       return e;
     }
@@ -160,7 +160,9 @@ export class MongoError extends Error {
         : e.errors.map(({ message }) => message).join(', ');
     }
 
-    return e.message;
+    return e != null && typeof e === 'object' && 'message' in e && typeof e.message === 'string'
+      ? e.message
+      : 'empty error message';
   }
 
   override get name(): string {
@@ -1145,14 +1147,12 @@ const RETRYABLE_READ_ERROR_CODES = new Set<number>([
   MONGODB_ERROR_CODES.InterruptedAtShutdown,
   MONGODB_ERROR_CODES.InterruptedDueToReplStateChange,
   MONGODB_ERROR_CODES.NotPrimaryNoSecondaryOk,
-  MONGODB_ERROR_CODES.NotPrimaryOrSecondary
+  MONGODB_ERROR_CODES.NotPrimaryOrSecondary,
+  MONGODB_ERROR_CODES.ExceededTimeLimit
 ]);
 
 // see: https://github.com/mongodb/specifications/blob/master/source/retryable-writes/retryable-writes.rst#terms
-const RETRYABLE_WRITE_ERROR_CODES = new Set<number>([
-  ...RETRYABLE_READ_ERROR_CODES,
-  MONGODB_ERROR_CODES.ExceededTimeLimit
-]);
+const RETRYABLE_WRITE_ERROR_CODES = RETRYABLE_READ_ERROR_CODES;
 
 export function needsRetryableWriteLabel(error: Error, maxWireVersion: number): boolean {
   // pre-4.4 server, then the driver adds an error label for every valid case

package/src/index.ts

@@ -147,6 +147,13 @@ export {
   TopologyDescriptionChangedEvent,
   TopologyOpeningEvent
 } from './sdam/events';
+export {
+  ServerSelectionEvent,
+  ServerSelectionFailedEvent,
+  ServerSelectionStartedEvent,
+  ServerSelectionSucceededEvent,
+  WaitingForSuitableServerEvent
+} from './sdam/server_selection_events';
 export { SrvPollingEvent } from './sdam/srv_polling';
 
 // type only exports below, these are removed from emitted JS
@@ -236,7 +243,7 @@ export type {
   CSFLEKMSTlsOptions,
   StateMachineExecutable
 } from './client-side-encryption/state_machine';
-export type { AuthContext } from './cmap/auth/auth_provider';
+export type { AuthContext, AuthProvider } from './cmap/auth/auth_provider';
 export type {
   AuthMechanismProperties,
   MongoCredentials,
@@ -261,6 +268,7 @@ export type {
   OpResponseOptions,
   WriteProtocolMessageType
 } from './cmap/commands';
+export type { HandshakeDocument } from './cmap/connect';
 export type { LEGAL_TCP_SOCKET_OPTIONS, LEGAL_TLS_SOCKET_OPTIONS, Stream } from './cmap/connect';
 export type {
   CommandOptions,
@@ -268,11 +276,7 @@ export type {
   ConnectionEvents,
   ConnectionOptions,
   DestroyOptions,
-  ModernConnection,
-  ProxyOptions,
-  read,
-  readMany,
-  writeCommand
+  ProxyOptions
 } from './cmap/connection';
 export type {
   CloseOptions,
@@ -284,16 +288,14 @@ export type {
   WithConnectionCallback
 } from './cmap/connection_pool';
 export type { ClientMetadata, ClientMetadataOptions } from './cmap/handshake/client_metadata';
-export type {
-  MessageStream,
-  MessageStreamOptions,
-  OperationDescription
-} from './cmap/message_stream';
 export type { ConnectionPoolMetrics } from './cmap/metrics';
 export type { StreamDescription, StreamDescriptionOptions } from './cmap/stream_description';
 export type { CompressorName } from './cmap/wire_protocol/compression';
 export type { CollectionOptions, CollectionPrivate, ModifyResult } from './collection';
 export type {
+  COMMAND_FAILED,
+  COMMAND_STARTED,
+  COMMAND_SUCCEEDED,
   CONNECTION_CHECK_OUT_FAILED,
   CONNECTION_CHECK_OUT_STARTED,
   CONNECTION_CHECKED_IN,
@@ -305,7 +307,20 @@ export type {
   CONNECTION_POOL_CREATED,
   CONNECTION_POOL_READY,
   CONNECTION_READY,
-  MONGO_CLIENT_EVENTS
+  MONGO_CLIENT_EVENTS,
+  SERVER_CLOSED,
+  SERVER_DESCRIPTION_CHANGED,
+  SERVER_HEARTBEAT_FAILED,
+  SERVER_HEARTBEAT_STARTED,
+  SERVER_HEARTBEAT_SUCCEEDED,
+  SERVER_OPENING,
+  SERVER_SELECTION_FAILED,
+  SERVER_SELECTION_STARTED,
+  SERVER_SELECTION_SUCCEEDED,
+  TOPOLOGY_CLOSED,
+  TOPOLOGY_DESCRIPTION_CHANGED,
+  TOPOLOGY_OPENING,
+  WAITING_FOR_SUITABLE_SERVER
 } from './constants';
 export type {
   AbstractCursorEvents,
@@ -351,12 +366,18 @@ export type {
   SupportedTLSSocketOptions,
   WithSessionCallback
 } from './mongo_client';
+export { MongoClientAuthProviders } from './mongo_client_auth_providers';
 export type {
   Log,
   LogComponentSeveritiesClientOptions,
   LogConvertible,
   Loggable,
+  LoggableCommandFailedEvent,
+  LoggableCommandSucceededEvent,
   LoggableEvent,
+  LoggableServerHeartbeatFailedEvent,
+  LoggableServerHeartbeatStartedEvent,
+  LoggableServerHeartbeatSucceededEvent,
   MongoDBLogWritable,
   MongoLoggableComponent,
   MongoLogger,

package/src/mongo_client.ts

@@ -21,11 +21,13 @@ import { MONGO_CLIENT_EVENTS } from './constants';
 import { Db, type DbOptions } from './db';
 import type { Encrypter } from './encrypter';
 import { MongoInvalidArgumentError } from './error';
+import { MongoClientAuthProviders } from './mongo_client_auth_providers';
 import {
   type LogComponentSeveritiesClientOptions,
   type MongoDBLogWritable,
   MongoLogger,
-  type MongoLoggerOptions
+  type MongoLoggerOptions,
+  SeverityLevel
 } from './mongo_logger';
 import { TypedEventEmitter } from './mongo_types';
 import { executeOperation } from './operations/execute_operation';
@@ -118,6 +120,8 @@ export type SupportedNodeConnectionOptions = SupportedTLSConnectionOptions &
 export interface MongoClientOptions extends BSONSerializeOptions, SupportedNodeConnectionOptions {
   /** Specifies the name of the replica set, if the mongod is a member of a replica set. */
   replicaSet?: string;
+  /** @internal This option is in development and currently has no behaviour. */
+  timeoutMS?: number;
   /** Enables or disables TLS/SSL for the connection. */
   tls?: boolean;
   /** A boolean to enable or disables TLS/SSL for the connection. (The ssl option is equivalent to the tls option.) */
@@ -294,6 +298,7 @@ export interface MongoClientPrivate {
   bsonOptions: BSONSerializeOptions;
   namespace: MongoDBNamespace;
   hasBeenClosed: boolean;
+  authProviders: MongoClientAuthProviders;
   /**
    * We keep a reference to the sessions that are acquired from the pool.
    * - used to track and close all sessions in client.close() (which is non-standard behavior)
@@ -316,6 +321,7 @@ export type MongoClientEvents = Pick<TopologyEvents, (typeof MONGO_CLIENT_EVENTS
 };
 
 /** @internal */
+
 const kOptions = Symbol('options');
 
 /**
@@ -343,7 +349,7 @@ export class MongoClient extends TypedEventEmitter<MongoClientEvents> {
   /** @internal */
   topology?: Topology;
   /** @internal */
-  override readonly mongoLogger: MongoLogger;
+  override readonly mongoLogger: MongoLogger | undefined;
   /** @internal */
   private connectionLock?: Promise<this>;
 
@@ -357,7 +363,13 @@ export class MongoClient extends TypedEventEmitter<MongoClientEvents> {
     super();
 
     this[kOptions] = parseOptions(url, this, options);
-    this.mongoLogger = new MongoLogger(this[kOptions].mongoLoggerOptions);
+
+    const shouldSetLogger = Object.values(
+      this[kOptions].mongoLoggerOptions.componentSeverities
+    ).some(value => value !== SeverityLevel.OFF);
+    this.mongoLogger = shouldSetLogger
+      ? new MongoLogger(this[kOptions].mongoLoggerOptions)
+      : undefined;
 
     // eslint-disable-next-line @typescript-eslint/no-this-alias
     const client = this;
@@ -370,6 +382,7 @@ export class MongoClient extends TypedEventEmitter<MongoClientEvents> {
       hasBeenClosed: false,
       sessionPool: new ServerSessionPool(this),
       activeSessions: new Set(),
+      authProviders: new MongoClientAuthProviders(),
 
       get options() {
         return client[kOptions];
@@ -403,9 +416,9 @@ export class MongoClient extends TypedEventEmitter<MongoClientEvents> {
     const srvHostIsCosmosDB = isHostMatch(COSMOS_DB_CHECK, this[kOptions].srvHost);
 
     if (documentDBHostnames.length !== 0 || srvHostIsDocumentDB) {
-      this.mongoLogger.info('client', DOCUMENT_DB_MSG);
+      this.mongoLogger?.info('client', DOCUMENT_DB_MSG);
     } else if (cosmosDBHostnames.length !== 0 || srvHostIsCosmosDB) {
-      this.mongoLogger.info('client', COSMOS_DB_MSG);
+      this.mongoLogger?.info('client', COSMOS_DB_MSG);
     }
   }
 
@@ -820,10 +833,10 @@ export interface MongoOptions
   proxyUsername?: string;
   proxyPassword?: string;
   serverMonitoringMode: ServerMonitoringMode;
-
   /** @internal */
   connectionType?: typeof Connection;
-
+  /** @internal */
+  authProviders: MongoClientAuthProviders;
   /** @internal */
   encrypter: Encrypter;
   /** @internal */

package/src/mongo_client_auth_providers.ts

@@ -0,0 +1,54 @@
+import { type AuthProvider } from './cmap/auth/auth_provider';
+import { GSSAPI } from './cmap/auth/gssapi';
+import { MongoCR } from './cmap/auth/mongocr';
+import { MongoDBAWS } from './cmap/auth/mongodb_aws';
+import { MongoDBOIDC } from './cmap/auth/mongodb_oidc';
+import { Plain } from './cmap/auth/plain';
+import { AuthMechanism } from './cmap/auth/providers';
+import { ScramSHA1, ScramSHA256 } from './cmap/auth/scram';
+import { X509 } from './cmap/auth/x509';
+import { MongoInvalidArgumentError } from './error';
+
+/** @internal */
+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()]
+]);
+
+/**
+ * Create a set of providers per client
+ * to avoid sharing the provider's cache between different clients.
+ * @internal
+ */
+export class MongoClientAuthProviders {
+  private existingProviders: Map<AuthMechanism | string, AuthProvider> = new Map();
+
+  /**
+   * Get or create an authentication provider based on the provided mechanism.
+   * We don't want to create all providers at once, as some providers may not be used.
+   * @param name - The name of the provider to get or create.
+   * @returns The provider.
+   * @throws MongoInvalidArgumentError if the mechanism is not supported.
+   * @internal
+   */
+  getOrCreateProvider(name: AuthMechanism | string): AuthProvider {
+    const authProvider = this.existingProviders.get(name);
+    if (authProvider) {
+      return authProvider;
+    }
+
+    const provider = AUTH_PROVIDERS.get(name)?.();
+    if (!provider) {
+      throw new MongoInvalidArgumentError(`authMechanism ${name} not supported`);
+    }
+
+    this.existingProviders.set(name, provider);
+    return provider;
+  }
+}