mongodb 6.4.0 → 6.5.0

package/src/cmap/wire_protocol/on_data.ts

@@ -16,11 +16,9 @@ type PendingPromises = Omit<
  * https://nodejs.org/api/events.html#eventsonemitter-eventname-options
  *
  * Returns an AsyncIterator that iterates each 'data' event emitted from emitter.
- * It will reject upon an error event or if the provided signal is aborted.
+ * It will reject upon an error event.
  */
-export function onData(emitter: EventEmitter, options: { signal: AbortSignal }) {
-  const signal = options.signal;
-
+export function onData(emitter: EventEmitter) {
   // Setup pending events and pending promise lists
   /**
    * When the caller has not yet called .next(), we store the
@@ -89,19 +87,8 @@ export function onData(emitter: EventEmitter, options: { signal: AbortSignal })
   emitter.on('data', eventHandler);
   emitter.on('error', errorHandler);
 
-  if (signal.aborted) {
-    // If the signal is aborted, set up the first .next() call to be a rejection
-    queueMicrotask(abortListener);
-  } else {
-    signal.addEventListener('abort', abortListener, { once: true });
-  }
-
   return iterator;
 
-  function abortListener() {
-    errorHandler(signal.reason);
-  }
-
   function eventHandler(value: Buffer) {
     const promise = unconsumedPromises.shift();
     if (promise != null) promise.resolve({ value, done: false });
@@ -119,7 +106,6 @@ export function onData(emitter: EventEmitter, options: { signal: AbortSignal })
     // Adding event handlers
     emitter.off('data', eventHandler);
     emitter.off('error', errorHandler);
-    signal.removeEventListener('abort', abortListener);
     finished = true;
     const doneResult = { value: undefined, done: finished } as const;
 

package/src/cmap/wire_protocol/shared.ts

@@ -13,12 +13,8 @@ export interface ReadPreferenceOption {
 }
 
 export function getReadPreference(options?: ReadPreferenceOption): ReadPreference {
-  // Default to command version of the readPreference
+  // Default to command version of the readPreference.
   let readPreference = options?.readPreference ?? ReadPreference.primary;
-  // If we have an option readPreference override the command one
-  if (options?.readPreference) {
-    readPreference = options.readPreference;
-  }
 
   if (typeof readPreference === 'string') {
     readPreference = ReadPreference.fromString(readPreference);
@@ -43,7 +39,7 @@ export function isSharded(topologyOrServer?: Topology | Server | Connection): bo
   }
 
   // NOTE: This is incredibly inefficient, and should be removed once command construction
-  //       happens based on `Server` not `Topology`.
+  // happens based on `Server` not `Topology`.
   if (topologyOrServer.description && topologyOrServer.description instanceof TopologyDescription) {
     const servers: ServerDescription[] = Array.from(topologyOrServer.description.servers.values());
     return servers.some((server: ServerDescription) => server.type === ServerType.Mongos);

package/src/connection_string.ts

@@ -5,7 +5,7 @@ import { URLSearchParams } from 'url';
 import type { Document } from './bson';
 import { MongoCredentials } from './cmap/auth/mongo_credentials';
 import { AUTH_MECHS_AUTH_SRC_EXTERNAL, AuthMechanism } from './cmap/auth/providers';
-import { makeClientMetadata } from './cmap/handshake/client_metadata';
+import { addContainerMetadata, makeClientMetadata } from './cmap/handshake/client_metadata';
 import { Compressor, type CompressorName } from './cmap/wire_protocol/compression';
 import { Encrypter } from './encrypter';
 import {
@@ -68,8 +68,15 @@ export async function resolveSRVRecord(options: MongoOptions): Promise<HostAddre
     throw new MongoAPIError('URI must include hostname, domain name, and tld');
   }
 
-  // Resolve the SRV record and use the result as the list of hosts to connect to.
+  // Asynchronously start TXT resolution so that we do not have to wait until
+  // the SRV record is resolved before starting a second DNS query.
   const lookupAddress = options.srvHost;
+  const txtResolutionPromise = dns.promises.resolveTxt(lookupAddress);
+  txtResolutionPromise.catch(() => {
+    /* rejections will be handled later */
+  });
+
+  // Resolve the SRV record and use the result as the list of hosts to connect to.
   const addresses = await dns.promises.resolveSrv(
     `_${options.srvServiceName}._tcp.${lookupAddress}`
   );
@@ -88,10 +95,10 @@ export async function resolveSRVRecord(options: MongoOptions): Promise<HostAddre
 
   validateLoadBalancedOptions(hostAddresses, options, true);
 
-  // Resolve TXT record and add options from there if they exist.
+  // Use the result of resolving the TXT record and add options from there if they exist.
   let record;
   try {
-    record = await dns.promises.resolveTxt(lookupAddress);
+    record = await txtResolutionPromise;
   } catch (error) {
     if (error.code !== 'ENODATA' && error.code !== 'ENOTFOUND') {
       throw error;
@@ -545,6 +552,10 @@ export function parseOptions(
 
   mongoOptions.metadata = makeClientMetadata(mongoOptions);
 
+  mongoOptions.extendedMetadata = addContainerMetadata(mongoOptions.metadata).catch(() => {
+    /* rejections will be handled later */
+  });
+
   return mongoOptions;
 }
 

package/src/error.ts

@@ -200,6 +200,8 @@ export class MongoError extends Error {
  * @category Error
  */
 export class MongoServerError extends MongoError {
+  /** Raw error result document returned by server. */
+  errorResponse: ErrorDescription;
   codeName?: string;
   writeConcernError?: Document;
   errInfo?: Document;
@@ -223,9 +225,17 @@ export class MongoServerError extends MongoError {
       this[kErrorLabels] = new Set(message.errorLabels);
     }
 
+    this.errorResponse = message;
+
     for (const name in message) {
-      if (name !== 'errorLabels' && name !== 'errmsg' && name !== 'message')
+      if (
+        name !== 'errorLabels' &&
+        name !== 'errmsg' &&
+        name !== 'message' &&
+        name !== 'errorResponse'
+      ) {
         this[name] = message[name];
+      }
     }
   }
 

package/src/index.ts

@@ -275,7 +275,6 @@ export type {
   Connection,
   ConnectionEvents,
   ConnectionOptions,
-  DestroyOptions,
   ProxyOptions
 } from './cmap/connection';
 export type {

package/src/mongo_client.ts

@@ -86,7 +86,7 @@ export interface Auth {
 
 /** @public */
 export interface PkFactory {
-  createPk(): any; // TODO: when js-bson is typed, function should return some BSON type
+  createPk(): any;
 }
 
 /** @public */
@@ -552,7 +552,7 @@ export class MongoClient extends TypedEventEmitter<MongoClientEvents> {
       try {
         await promisify(callback => this.topology?.connect(options, callback))();
       } catch (error) {
-        this.topology?.close({ force: true });
+        this.topology?.close();
         throw error;
       }
     };
@@ -614,19 +614,12 @@ export class MongoClient extends TypedEventEmitter<MongoClientEvents> {
     const topology = this.topology;
     this.topology = undefined;
 
-    await new Promise<void>((resolve, reject) => {
-      topology.close({ force }, error => {
-        if (error) return reject(error);
-        const { encrypter } = this[kOptions];
-        if (encrypter) {
-          return encrypter.closeCallback(this, force, error => {
-            if (error) return reject(error);
-            resolve();
-          });
-        }
-        resolve();
-      });
-    });
+    topology.close();
+
+    const { encrypter } = this[kOptions];
+    if (encrypter) {
+      await encrypter.close(this, force);
+    }
   }
 
   /**
@@ -821,12 +814,15 @@ export interface MongoOptions
   readPreference: ReadPreference;
   readConcern: ReadConcern;
   loadBalanced: boolean;
+  directConnection: boolean;
   serverApi: ServerApi;
   compressors: CompressorName[];
   writeConcern: WriteConcern;
   dbName: string;
   metadata: ClientMetadata;
   /** @internal */
+  extendedMetadata: Promise<Document>;
+  /** @internal */
   autoEncrypter?: AutoEncrypter;
   proxyHost?: string;
   proxyPort?: number;

package/src/mongo_logger.ts

@@ -220,7 +220,8 @@ export function createStdioLogger(stream: {
 }): MongoDBLogWritable {
   return {
     write: promisify((log: Log, cb: (error?: Error) => void): unknown => {
-      stream.write(inspect(log, { compact: true, breakLength: Infinity }), 'utf-8', cb);
+      const logLine = inspect(log, { compact: true, breakLength: Infinity });
+      stream.write(`${logLine}\n`, 'utf-8', cb);
       return;
     })
   };

package/src/operations/common_functions.ts

@@ -43,11 +43,21 @@ export async function indexInformation(
   return info;
 }
 
-export function prepareDocs(
+export function maybeAddIdToDocuments(
   coll: Collection,
   docs: Document[],
   options: { forceServerObjectId?: boolean }
-): Document[] {
+): Document[];
+export function maybeAddIdToDocuments(
+  coll: Collection,
+  docs: Document,
+  options: { forceServerObjectId?: boolean }
+): Document;
+export function maybeAddIdToDocuments(
+  coll: Collection,
+  docOrDocs: Document[] | Document,
+  options: { forceServerObjectId?: boolean }
+): Document[] | Document {
   const forceServerObjectId =
     typeof options.forceServerObjectId === 'boolean'
       ? options.forceServerObjectId
@@ -55,14 +65,15 @@ export function prepareDocs(
 
   // no need to modify the docs if server sets the ObjectId
   if (forceServerObjectId === true) {
-    return docs;
+    return docOrDocs;
   }
 
-  return docs.map(doc => {
+  const transform = (doc: Document): Document => {
     if (doc._id == null) {
       doc._id = coll.s.pkFactory.createPk();
     }
 
     return doc;
-  });
+  };
+  return Array.isArray(docOrDocs) ? docOrDocs.map(transform) : transform(docOrDocs);
 }

package/src/operations/insert.ts

@@ -9,7 +9,7 @@ import type { MongoDBNamespace } from '../utils';
 import { WriteConcern } from '../write_concern';
 import { BulkWriteOperation } from './bulk_write';
 import { CommandOperation, type CommandOperationOptions } from './command';
-import { prepareDocs } from './common_functions';
+import { maybeAddIdToDocuments } from './common_functions';
 import { AbstractOperation, Aspect, defineAspects } from './operation';
 
 /** @internal */
@@ -69,7 +69,7 @@ export interface InsertOneResult<TSchema = Document> {
 
 export class InsertOneOperation extends InsertOperation {
   constructor(collection: Collection, doc: Document, options: InsertOneOptions) {
-    super(collection.s.namespace, prepareDocs(collection, [doc], options), options);
+    super(collection.s.namespace, maybeAddIdToDocuments(collection, [doc], options), options);
   }
 
   override async execute(
@@ -131,7 +131,9 @@ export class InsertManyOperation extends AbstractOperation<InsertManyResult> {
     const writeConcern = WriteConcern.fromOptions(options);
     const bulkWriteOperation = new BulkWriteOperation(
       coll,
-      prepareDocs(coll, this.docs, options).map(document => ({ insertOne: { document } })),
+      this.docs.map(document => ({
+        insertOne: { document }
+      })),
       options
     );
 

package/src/sdam/monitor.ts

@@ -214,7 +214,7 @@ function resetMonitorState(monitor: Monitor) {
 
   monitor[kCancellationToken].emit('cancel');
 
-  monitor.connection?.destroy({ force: true });
+  monitor.connection?.destroy();
   monitor.connection = null;
 }
 
@@ -247,7 +247,7 @@ function checkServer(monitor: Monitor, callback: Callback<Document | null>) {
   );
 
   function onHeartbeatFailed(err: Error) {
-    monitor.connection?.destroy({ force: true });
+    monitor.connection?.destroy();
     monitor.connection = null;
 
     monitor.emitAndLogHeartbeat(
@@ -366,13 +366,13 @@ function checkServer(monitor: Monitor, callback: Callback<Document | null>) {
       await performInitialHandshake(connection, monitor.connectOptions);
       return connection;
     } catch (error) {
-      connection.destroy({ force: false });
+      connection.destroy();
       throw error;
     }
   })().then(
     connection => {
       if (isInCloseState(monitor)) {
-        connection.destroy({ force: true });
+        connection.destroy();
         return;
       }
 
@@ -479,7 +479,7 @@ export class RTTPinger {
     this.closed = true;
     clearTimeout(this[kMonitorId]);
 
-    this.connection?.destroy({ force: true });
+    this.connection?.destroy();
     this.connection = undefined;
   }
 }
@@ -495,7 +495,7 @@ function measureRoundTripTime(rttPinger: RTTPinger, options: RTTPingerOptions) {
 
   function measureAndReschedule(conn?: Connection) {
     if (rttPinger.closed) {
-      conn?.destroy({ force: true });
+      conn?.destroy();
       return;
     }
 
@@ -529,7 +529,7 @@ function measureRoundTripTime(rttPinger: RTTPinger, options: RTTPingerOptions) {
   connection.command(ns('admin.$cmd'), { [commandName]: 1 }, undefined).then(
     () => measureAndReschedule(),
     () => {
-      rttPinger.connection?.destroy({ force: true });
+      rttPinger.connection?.destroy();
       rttPinger.connection = undefined;
       rttPinger[kRoundTripTime] = 0;
       return;

package/src/sdam/server.ts

@@ -1,6 +1,6 @@
 import type { Document } from '../bson';
 import { type AutoEncrypter } from '../client-side-encryption/auto_encrypter';
-import { type CommandOptions, Connection, type DestroyOptions } from '../cmap/connection';
+import { type CommandOptions, Connection } from '../cmap/connection';
 import {
   ConnectionPool,
   type ConnectionPoolEvents,
@@ -41,7 +41,6 @@ import type { GetMoreOptions } from '../operations/get_more';
 import type { ClientSession } from '../sessions';
 import { isTransactionCommand } from '../transactions';
 import {
-  type Callback,
   type EventEmitterWithState,
   makeStateMachine,
   maxWireVersion,
@@ -171,7 +170,7 @@ export class Server extends TypedEventEmitter<ServerEvents> {
       this.monitor.on(event, (e: any) => this.emit(event, e));
     }
 
-    this.monitor.on('resetServer', (error: MongoError) => markServerUnknown(this, error));
+    this.monitor.on('resetServer', (error: MongoServerError) => markServerUnknown(this, error));
     this.monitor.on(Server.SERVER_HEARTBEAT_SUCCEEDED, (event: ServerHeartbeatSucceededEvent) => {
       this.emit(
         Server.DESCRIPTION_RECEIVED,
@@ -236,18 +235,8 @@ export class Server extends TypedEventEmitter<ServerEvents> {
   }
 
   /** Destroy the server connection */
-  destroy(options?: DestroyOptions, callback?: Callback): void {
-    if (typeof options === 'function') {
-      callback = options;
-      options = { force: false };
-    }
-    options = Object.assign({}, { force: false }, options);
-
+  destroy(): void {
     if (this.s.state === STATE_CLOSED) {
-      if (typeof callback === 'function') {
-        callback();
-      }
-
       return;
     }
 
@@ -257,13 +246,9 @@ export class Server extends TypedEventEmitter<ServerEvents> {
       this.monitor?.close();
     }
 
-    this.pool.close(options, err => {
-      stateTransition(this, STATE_CLOSED);
-      this.emit('closed');
-      if (typeof callback === 'function') {
-        callback(err);
-      }
-    });
+    this.pool.close();
+    stateTransition(this, STATE_CLOSED);
+    this.emit('closed');
   }
 
   /**
@@ -290,7 +275,10 @@ export class Server extends TypedEventEmitter<ServerEvents> {
     }
 
     // Clone the options
-    const finalOptions = Object.assign({}, options, { wireProtocolCommand: false });
+    const finalOptions = Object.assign({}, options, {
+      wireProtocolCommand: false,
+      directConnection: this.topology.s.options.directConnection
+    });
 
     // There are cases where we need to flag the read preference not to get sent in
     // the command, such as pre-5.0 servers attempting to perform an aggregate write
@@ -369,7 +357,7 @@ export class Server extends TypedEventEmitter<ServerEvents> {
       // clear for the specific service id.
       if (!this.loadBalanced) {
         error.addErrorLabel(MongoErrorLabel.ResetPool);
-        markServerUnknown(this, error);
+        markServerUnknown(this, error as MongoServerError);
       } else if (connection) {
         this.pool.clear({ serviceId: connection.serviceId });
       }
@@ -385,7 +373,7 @@ export class Server extends TypedEventEmitter<ServerEvents> {
             if (shouldClearPool) {
               error.addErrorLabel(MongoErrorLabel.ResetPool);
             }
-            markServerUnknown(this, error);
+            markServerUnknown(this, error as MongoServerError);
             process.nextTick(() => this.requestCheck());
           }
         }

package/src/sdam/topology.ts

@@ -2,8 +2,8 @@ import { promisify } from 'util';
 
 import type { BSONSerializeOptions, Document } 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 type { ConnectionEvents } from '../cmap/connection';
+import type { ConnectionPoolEvents } from '../cmap/connection_pool';
 import type { ClientMetadata } from '../cmap/handshake/client_metadata';
 import { DEFAULT_OPTIONS, FEATURE_FLAGS } from '../connection_string';
 import {
@@ -158,6 +158,7 @@ export interface TopologyOptions extends BSONSerializeOptions, ServerOptions {
   directConnection: boolean;
   loadBalanced: boolean;
   metadata: ClientMetadata;
+  extendedMetadata: Promise<Document>;
   serverMonitoringMode: ServerMonitoringMode;
   /** MongoDB server API version */
   serverApi?: ServerApi;
@@ -468,7 +469,8 @@ export class Topology extends TypedEventEmitter<TopologyEvents> {
       selectServerOptions,
       (err, server) => {
         if (err) {
-          return this.close({ force: false }, () => exitWithError(err));
+          this.close();
+          return exitWithError(err);
         }
 
         const skipPingOnConnect = this.s.options[Symbol.for('@@mdb.skipPingOnConnect')] === true;
@@ -494,41 +496,33 @@ export class Topology extends TypedEventEmitter<TopologyEvents> {
   }
 
   /** Close this topology */
-  close(options: CloseOptions): void;
-  close(options: CloseOptions, callback: Callback): void;
-  close(options?: CloseOptions, callback?: Callback): void {
-    options = options ?? { force: false };
-
+  close(): void {
     if (this.s.state === STATE_CLOSED || this.s.state === STATE_CLOSING) {
-      return callback?.();
+      return;
     }
 
-    const destroyedServers = Array.from(this.s.servers.values(), server => {
-      return promisify(destroyServer)(server, this, { force: !!options?.force });
-    });
+    for (const server of this.s.servers.values()) {
+      destroyServer(server, this);
+    }
 
-    Promise.all(destroyedServers)
-      .then(() => {
-        this.s.servers.clear();
+    this.s.servers.clear();
 
-        stateTransition(this, STATE_CLOSING);
+    stateTransition(this, STATE_CLOSING);
 
-        drainWaitQueue(this[kWaitQueue], new MongoTopologyClosedError());
-        drainTimerQueue(this.s.connectionTimers);
+    drainWaitQueue(this[kWaitQueue], new MongoTopologyClosedError());
+    drainTimerQueue(this.s.connectionTimers);
 
-        if (this.s.srvPoller) {
-          this.s.srvPoller.stop();
-          this.s.srvPoller.removeListener(SrvPoller.SRV_RECORD_DISCOVERY, this.s.detectSrvRecords);
-        }
+    if (this.s.srvPoller) {
+      this.s.srvPoller.stop();
+      this.s.srvPoller.removeListener(SrvPoller.SRV_RECORD_DISCOVERY, this.s.detectSrvRecords);
+    }
 
-        this.removeListener(Topology.TOPOLOGY_DESCRIPTION_CHANGED, this.s.detectShardedTopology);
+    this.removeListener(Topology.TOPOLOGY_DESCRIPTION_CHANGED, this.s.detectShardedTopology);
 
-        stateTransition(this, STATE_CLOSED);
+    stateTransition(this, STATE_CLOSED);
 
-        // emit an event for close
-        this.emitAndLog(Topology.TOPOLOGY_CLOSED, new TopologyClosedEvent(this.s.id));
-      })
-      .finally(() => callback?.());
+    // emit an event for close
+    this.emitAndLog(Topology.TOPOLOGY_CLOSED, new TopologyClosedEvent(this.s.id));
   }
 
   /**
@@ -772,30 +766,20 @@ export class Topology extends TypedEventEmitter<TopologyEvents> {
 }
 
 /** Destroys a server, and removes all event listeners from the instance */
-function destroyServer(
-  server: Server,
-  topology: Topology,
-  options?: DestroyOptions,
-  callback?: Callback
-) {
-  options = options ?? { force: false };
+function destroyServer(server: Server, topology: Topology) {
   for (const event of LOCAL_SERVER_EVENTS) {
     server.removeAllListeners(event);
   }
 
-  server.destroy(options, () => {
-    topology.emitAndLog(
-      Topology.SERVER_CLOSED,
-      new ServerClosedEvent(topology.s.id, server.description.address)
-    );
+  server.destroy();
+  topology.emitAndLog(
+    Topology.SERVER_CLOSED,
+    new ServerClosedEvent(topology.s.id, server.description.address)
+  );
 
-    for (const event of SERVER_RELAY_EVENTS) {
-      server.removeAllListeners(event);
-    }
-    if (typeof callback === 'function') {
-      callback();
-    }
-  });
+  for (const event of SERVER_RELAY_EVENTS) {
+    server.removeAllListeners(event);
+  }
 }
 
 /** Predicts the TopologyType from options */

package/src/sdam/topology_description.ts

@@ -313,7 +313,7 @@ export class TopologyDescription {
     );
 
     if (descriptionsWithError.length > 0) {
-      return descriptionsWithError[0].error;
+      return descriptionsWithError[0].error as MongoServerError;
     }
 
     return null;

package/src/utils.ts

@@ -1,5 +1,6 @@
 import * as crypto from 'crypto';
 import type { SrvRecord } from 'dns';
+import { type EventEmitter } from 'events';
 import * as http from 'http';
 import { clearTimeout, setTimeout } from 'timers';
 import * as url from 'url';
@@ -385,46 +386,6 @@ export function maxWireVersion(topologyOrServer?: Connection | Topology | Server
   return 0;
 }
 
-/**
- * Applies the function `eachFn` to each item in `arr`, in parallel.
- * @internal
- *
- * @param arr - An array of items to asynchronously iterate over
- * @param eachFn - A function to call on each item of the array. The callback signature is `(item, callback)`, where the callback indicates iteration is complete.
- * @param callback - The callback called after every item has been iterated
- */
-export function eachAsync<T = Document>(
-  arr: T[],
-  eachFn: (item: T, callback: (err?: AnyError) => void) => void,
-  callback: Callback
-): void {
-  arr = arr || [];
-
-  let idx = 0;
-  let awaiting = 0;
-  for (idx = 0; idx < arr.length; ++idx) {
-    awaiting++;
-    eachFn(arr[idx], eachCallback);
-  }
-
-  if (awaiting === 0) {
-    callback();
-    return;
-  }
-
-  function eachCallback(err?: AnyError) {
-    awaiting--;
-    if (err) {
-      callback(err);
-      return;
-    }
-
-    if (idx === arr.length && awaiting <= 0) {
-      callback();
-    }
-  }
-}
-
 /** @internal */
 export function arrayStrictEqual(arr: unknown[], arr2: unknown[]): boolean {
   if (!Array.isArray(arr) || !Array.isArray(arr2)) {
@@ -1295,3 +1256,27 @@ export function promiseWithResolvers<T>() {
 }
 
 export const randomBytes = promisify(crypto.randomBytes);
+
+/**
+ * Replicates the events.once helper.
+ *
+ * Removes unused signal logic and It **only** supports 0 or 1 argument events.
+ *
+ * @param ee - An event emitter that may emit `ev`
+ * @param name - An event name to wait for
+ */
+export async function once<T>(ee: EventEmitter, name: string): Promise<T> {
+  const { promise, resolve, reject } = promiseWithResolvers<T>();
+  const onEvent = (data: T) => resolve(data);
+  const onError = (error: Error) => reject(error);
+
+  ee.once(name, onEvent).once('error', onError);
+  try {
+    const res = await promise;
+    ee.off('error', onError);
+    return res;
+  } catch (error) {
+    ee.off(name, onEvent);
+    throw error;
+  }
+}