mongodb 7.0.0 → 7.1.0-dev.20260205.sha.d2ad07f2

package/src/cmap/connection_pool.ts

@@ -36,7 +36,7 @@ import {
   List,
   makeCounter,
   noop,
-  now,
+  processTimeMS,
   promiseWithResolvers
 } from '../utils';
 import { connect } from './connect';
@@ -231,7 +231,7 @@ export class ConnectionPool extends TypedEventEmitter<ConnectionPoolEvents> {
     this.mongoLogger = this.server.topology.client?.mongoLogger;
     this.component = 'connection';
 
-    process.nextTick(() => {
+    queueMicrotask(() => {
       this.emitAndLog(ConnectionPool.CONNECTION_POOL_CREATED, new ConnectionPoolCreatedEvent(this));
     });
   }
@@ -319,7 +319,7 @@ export class ConnectionPool extends TypedEventEmitter<ConnectionPoolEvents> {
    * explicitly destroyed by the new owner.
    */
   async checkOut(options: { timeoutContext: TimeoutContext } & Abortable): Promise<Connection> {
-    const checkoutTime = now();
+    const checkoutTime = processTimeMS();
     this.emitAndLog(
       ConnectionPool.CONNECTION_CHECK_OUT_STARTED,
       new ConnectionCheckOutStartedEvent(this)
@@ -342,7 +342,7 @@ export class ConnectionPool extends TypedEventEmitter<ConnectionPoolEvents> {
     });
 
     this.waitQueue.push(waitQueueMember);
-    process.nextTick(() => this.processWaitQueue());
+    queueMicrotask(() => this.processWaitQueue());
 
     try {
       timeout?.throwIfExpired();
@@ -405,7 +405,7 @@ export class ConnectionPool extends TypedEventEmitter<ConnectionPoolEvents> {
       this.destroyConnection(connection, reason);
     }
 
-    process.nextTick(() => this.processWaitQueue());
+    queueMicrotask(() => this.processWaitQueue());
   }
 
   /**
@@ -461,7 +461,7 @@ export class ConnectionPool extends TypedEventEmitter<ConnectionPoolEvents> {
     }
 
     if (interruptInUseConnections) {
-      process.nextTick(() => this.interruptInUseConnections(oldGeneration));
+      queueMicrotask(() => this.interruptInUseConnections(oldGeneration));
     }
 
     this.processWaitQueue();
@@ -616,7 +616,7 @@ export class ConnectionPool extends TypedEventEmitter<ConnectionPoolEvents> {
 
     this.pending++;
     // This is our version of a "virtual" no-I/O connection as the spec requires
-    const connectionCreatedTime = now();
+    const connectionCreatedTime = processTimeMS();
     this.emitAndLog(
       ConnectionPool.CONNECTION_CREATED,
       new ConnectionCreatedEvent(this, { id: connectOptions.id })
@@ -702,7 +702,7 @@ export class ConnectionPool extends TypedEventEmitter<ConnectionPoolEvents> {
       this.createConnection((err, connection) => {
         if (!err && connection) {
           this.connections.push(connection);
-          process.nextTick(() => this.processWaitQueue());
+          queueMicrotask(() => this.processWaitQueue());
         }
         if (this.poolState === PoolState.ready) {
           clearTimeout(this.minPoolSizeTimer);
@@ -809,7 +809,7 @@ export class ConnectionPool extends TypedEventEmitter<ConnectionPoolEvents> {
             waitQueueMember.resolve(connection);
           }
         }
-        process.nextTick(() => this.processWaitQueue());
+        queueMicrotask(() => this.processWaitQueue());
       });
     }
     this.processingWaitQueue = false;

package/src/cmap/connection_pool_events.ts

@@ -13,7 +13,7 @@ import {
   CONNECTION_READY
 } from '../constants';
 import type { MongoError } from '../error';
-import { now } from '../utils';
+import { processTimeMS } from '../utils';
 import type { Connection } from './connection';
 import type { ConnectionPool, ConnectionPoolOptions } from './connection_pool';
 
@@ -145,7 +145,7 @@ export class ConnectionReadyEvent extends ConnectionPoolMonitoringEvent {
   /** @internal */
   constructor(pool: ConnectionPool, connection: Connection, connectionCreatedEventTime: number) {
     super(pool);
-    this.durationMS = now() - connectionCreatedEventTime;
+    this.durationMS = processTimeMS() - connectionCreatedEventTime;
     this.connectionId = connection.id;
   }
 }
@@ -224,7 +224,7 @@ export class ConnectionCheckOutFailedEvent extends ConnectionPoolMonitoringEvent
     error?: MongoError
   ) {
     super(pool);
-    this.durationMS = now() - checkoutTime;
+    this.durationMS = processTimeMS() - checkoutTime;
     this.reason = reason;
     this.error = error;
   }
@@ -252,7 +252,7 @@ export class ConnectionCheckedOutEvent extends ConnectionPoolMonitoringEvent {
   /** @internal */
   constructor(pool: ConnectionPool, connection: Connection, checkoutTime: number) {
     super(pool);
-    this.durationMS = now() - checkoutTime;
+    this.durationMS = processTimeMS() - checkoutTime;
     this.connectionId = connection.id;
   }
 }

package/src/cmap/handshake/client_metadata.ts

@@ -1,7 +1,6 @@
-import * as os from 'os';
 import * as process from 'process';
 
-import { BSON, type Document, Int32 } from '../../bson';
+import { BSON, type Document, Int32, NumberUtils } from '../../bson';
 import { MongoInvalidArgumentError } from '../../error';
 import type { DriverInfo, MongoOptions } from '../../mongo_client';
 import { fileIsAccessible } from '../../utils';
@@ -96,7 +95,8 @@ export class LimitedSizeDocument {
   }
 }
 
-type MakeClientMetadataOptions = Pick<MongoOptions, 'appName'>;
+type MakeClientMetadataOptions = Pick<MongoOptions, 'appName' | 'runtime'>;
+
 /**
  * From the specs:
  * Implementors SHOULD cumulatively update fields in the following order until the document is under the size limit:
@@ -107,7 +107,7 @@ type MakeClientMetadataOptions = Pick<MongoOptions, 'appName'>;
  */
 export async function makeClientMetadata(
   driverInfoList: DriverInfo[],
-  { appName = '' }: MakeClientMetadataOptions
+  { appName = '', runtime: { os } }: MakeClientMetadataOptions
 ): Promise<ClientMetadata> {
   const metadataDocument = new LimitedSizeDocument(512);
 
@@ -157,8 +157,8 @@ export async function makeClientMetadata(
 
   // Note: order matters, os.type is last so it will be removed last if we're at maxSize
   const osInfo = new Map()
-    .set('name', process.platform)
-    .set('architecture', process.arch)
+    .set('name', os.platform())
+    .set('architecture', os.arch())
     .set('version', os.release())
     .set('type', os.type());
 
@@ -336,17 +336,18 @@ declare const Bun: { (): void; version?: string } | undefined;
  * with a future change to these global objects.
  */
 function getRuntimeInfo(): string {
+  const endianness = NumberUtils.isBigEndian ? 'BE' : 'LE';
   if ('Deno' in globalThis) {
     const version = typeof Deno?.version?.deno === 'string' ? Deno?.version?.deno : '0.0.0-unknown';
 
-    return `Deno v${version}, ${os.endianness()}`;
+    return `Deno v${version}, ${endianness}`;
   }
 
   if ('Bun' in globalThis) {
     const version = typeof Bun?.version === 'string' ? Bun?.version : '0.0.0-unknown';
 
-    return `Bun v${version}, ${os.endianness()}`;
+    return `Bun v${version}, ${endianness}`;
   }
 
-  return `Node.js ${process.version}, ${os.endianness()}`;
+  return `Node.js ${process.version}, ${endianness}`;
 }

package/src/cmap/wire_protocol/compression.ts

@@ -1,4 +1,3 @@
-import { promisify } from 'util';
 import * as zlib from 'zlib';
 
 import { LEGACY_HELLO_COMMAND } from '../../constants';
@@ -43,8 +42,23 @@ export const uncompressibleCommands = new Set([
 
 const ZSTD_COMPRESSION_LEVEL = 3;
 
-const zlibInflate = promisify(zlib.inflate.bind(zlib));
-const zlibDeflate = promisify(zlib.deflate.bind(zlib));
+const zlibInflate = (buf: zlib.InputType) => {
+  return new Promise<Buffer>((resolve, reject) => {
+    zlib.inflate(buf, (error, result) => {
+      if (error) return reject(error);
+      resolve(result);
+    });
+  });
+};
+
+const zlibDeflate = (buf: zlib.InputType, options: zlib.ZlibOptions) => {
+  return new Promise<Buffer>((resolve, reject) => {
+    zlib.deflate(buf, options, (error, result) => {
+      if (error) return reject(error);
+      resolve(result);
+    });
+  });
+};
 
 let zstd: ZStandard;
 let Snappy: SnappyLib | null = null;

package/src/connection_string.ts

@@ -1,5 +1,6 @@
 import * as dns from 'dns';
 import ConnectionString from 'mongodb-connection-string-url';
+import * as process from 'process';
 import { URLSearchParams } from 'url';
 
 import type { Document } from './bson';
@@ -19,6 +20,7 @@ import {
 import { MongoLoggableComponent, MongoLogger, SeverityLevel } from './mongo_logger';
 import { ReadConcern, type ReadConcernLevel } from './read_concern';
 import { ReadPreference, type ReadPreferenceMode } from './read_preference';
+import { resolveRuntimeAdapters } from './runtime_adapters';
 import { ServerMonitoringMode } from './sdam/monitor';
 import type { TagSet } from './sdam/server_description';
 import {
@@ -537,6 +539,8 @@ export function parseOptions(
     }
   );
 
+  mongoOptions.runtime = resolveRuntimeAdapters(options);
+
   return mongoOptions;
 }
 
@@ -1060,6 +1064,9 @@ export const OPTIONS = {
     default: true,
     type: 'boolean'
   },
+  runtimeAdapters: {
+    type: 'record'
+  },
   serializeFunctions: {
     type: 'boolean'
   },

package/src/db.ts

@@ -394,7 +394,6 @@ export class Db {
         toCollection,
         resolveOptions(undefined, {
           ...options,
-          new_collection: true,
           readPreference: ReadPreference.primary
         })
       ) as TODO_NODE_3286

package/src/deps.ts

@@ -203,66 +203,6 @@ export function getSocks(): SocksLib | { kModuleError: MongoMissingDependencyErr
   }
 }
 
-interface AWS4 {
-  /**
-   * Created these inline types to better assert future usage of this API
-   * @param options - options for request
-   * @param credentials - AWS credential details, sessionToken should be omitted entirely if its false-y
-   */
-  sign(
-    this: void,
-    options: {
-      path: '/';
-      body: string;
-      host: string;
-      method: 'POST';
-      headers: {
-        'Content-Type': 'application/x-www-form-urlencoded';
-        'Content-Length': number;
-        'X-MongoDB-Server-Nonce': string;
-        'X-MongoDB-GS2-CB-Flag': 'n';
-      };
-      service: string;
-      region: string;
-    },
-    credentials:
-      | {
-          accessKeyId: string;
-          secretAccessKey: string;
-          sessionToken: string;
-        }
-      | {
-          accessKeyId: string;
-          secretAccessKey: string;
-        }
-      | undefined
-  ): {
-    headers: {
-      Authorization: string;
-      'X-Amz-Date': string;
-    };
-  };
-}
-
-export const aws4: AWS4 | { kModuleError: MongoMissingDependencyError } = loadAws4();
-
-function loadAws4() {
-  let aws4: AWS4 | { kModuleError: MongoMissingDependencyError };
-  try {
-    // eslint-disable-next-line @typescript-eslint/no-require-imports
-    aws4 = require('aws4');
-  } catch (error) {
-    aws4 = makeErrorModule(
-      new MongoMissingDependencyError(
-        'Optional module `aws4` not found. Please install it to enable AWS authentication',
-        { cause: error, dependencyName: 'aws4' }
-      )
-    );
-  }
-
-  return aws4;
-}
-
 /** A utility function to get the instance of mongodb-client-encryption, if it exists. */
 export function getMongoDBClientEncryption():
   | typeof import('mongodb-client-encryption')

package/src/error.ts

@@ -99,7 +99,9 @@ export const MongoErrorLabel = Object.freeze({
   ResetPool: 'ResetPool',
   PoolRequestedRetry: 'PoolRequestedRetry',
   InterruptInUseConnections: 'InterruptInUseConnections',
-  NoWritesPerformed: 'NoWritesPerformed'
+  NoWritesPerformed: 'NoWritesPerformed',
+  RetryableError: 'RetryableError',
+  SystemOverloadedError: 'SystemOverloadedError'
 } as const);
 
 /** @public */
@@ -1528,13 +1530,7 @@ export function isNodeShuttingDownError(err: MongoError): boolean {
  *
  * @see https://github.com/mongodb/specifications/blob/master/source/server-discovery-and-monitoring/server-discovery-and-monitoring.md#not-writable-primary-and-node-is-recovering
  */
-export function isSDAMUnrecoverableError(error: MongoError): boolean {
-  // NOTE: null check is here for a strictly pre-CMAP world, a timeout or
-  //       close event are considered unrecoverable
-  if (error instanceof MongoParseError || error == null) {
-    return true;
-  }
-
+export function isStateChangeError(error: MongoError): boolean {
   return isRecoveringError(error) || isNotWritablePrimaryError(error);
 }
 

package/src/gridfs/upload.ts

@@ -165,7 +165,7 @@ export class GridFSBucketWriteStream extends Writable {
         }
       );
     } else {
-      return process.nextTick(callback);
+      return queueMicrotask(callback);
     }
   }
 
@@ -188,7 +188,7 @@ export class GridFSBucketWriteStream extends Writable {
   /** @internal */
   override _final(callback: (error?: Error | null) => void): void {
     if (this.state.streamEnd) {
-      return process.nextTick(callback);
+      return queueMicrotask(callback);
     }
     this.state.streamEnd = true;
     writeRemnant(this, callback);
@@ -220,11 +220,11 @@ export class GridFSBucketWriteStream extends Writable {
 
 function handleError(stream: GridFSBucketWriteStream, error: Error, callback: Callback): void {
   if (stream.state.errored) {
-    process.nextTick(callback);
+    queueMicrotask(callback);
     return;
   }
   stream.state.errored = true;
-  process.nextTick(callback, error);
+  queueMicrotask(() => callback(error));
 }
 
 function createChunkDoc(filesId: ObjectId, n: number, data: Buffer): GridFSChunk {
@@ -283,7 +283,7 @@ async function checkChunksIndex(stream: GridFSBucketWriteStream): Promise<void>
 
 function checkDone(stream: GridFSBucketWriteStream, callback: Callback): void {
   if (stream.done) {
-    return process.nextTick(callback);
+    return queueMicrotask(callback);
   }
 
   if (stream.state.streamEnd && stream.state.outstandingRequests === 0 && !stream.state.errored) {
@@ -327,7 +327,7 @@ function checkDone(stream: GridFSBucketWriteStream, callback: Callback): void {
     return;
   }
 
-  process.nextTick(callback);
+  queueMicrotask(callback);
 }
 
 async function checkIndexes(stream: GridFSBucketWriteStream): Promise<void> {
@@ -425,7 +425,7 @@ function doWrite(
   if (stream.pos + inputBuf.length < stream.chunkSizeBytes) {
     inputBuf.copy(stream.bufToStore, stream.pos);
     stream.pos += inputBuf.length;
-    process.nextTick(callback);
+    queueMicrotask(callback);
     return;
   }
 
@@ -530,7 +530,7 @@ function writeRemnant(stream: GridFSBucketWriteStream, callback: Callback): void
 
 function isAborted(stream: GridFSBucketWriteStream, callback: Callback<void>): boolean {
   if (stream.state.aborted) {
-    process.nextTick(callback, new MongoAPIError('Stream has been aborted'));
+    queueMicrotask(() => callback(new MongoAPIError('Stream has been aborted')));
     return true;
   }
   return false;

package/src/index.ts

@@ -562,6 +562,7 @@ export type {
   ReadPreferenceLikeOptions,
   ReadPreferenceOptions
 } from './read_preference';
+export type { OsAdapter, Runtime, RuntimeAdapters } from './runtime_adapters';
 export type { ClusterTime } from './sdam/common';
 export type {
   Monitor,
@@ -588,7 +589,7 @@ export type {
   TagSet,
   TopologyVersion
 } from './sdam/server_description';
-export type { ServerSelector } from './sdam/server_selection';
+export type { DeprioritizedServers, ServerSelector } from './sdam/server_selection';
 export type { SrvPoller, SrvPollerEvents, SrvPollerOptions } from './sdam/srv_polling';
 export type {
   ConnectOptions,

package/src/mongo_client.ts

@@ -46,9 +46,10 @@ import { EndSessionsOperation } from './operations/end_sessions';
 import { executeOperation } from './operations/execute_operation';
 import type { ReadConcern, ReadConcernLevel, ReadConcernLike } from './read_concern';
 import { ReadPreference, type ReadPreferenceMode } from './read_preference';
+import { type Runtime, type RuntimeAdapters } from './runtime_adapters';
 import type { ServerMonitoringMode } from './sdam/monitor';
 import type { TagSet } from './sdam/server_description';
-import { readPreferenceServerSelector } from './sdam/server_selection';
+import { DeprioritizedServers, readPreferenceServerSelector } from './sdam/server_selection';
 import type { SrvPoller } from './sdam/srv_polling';
 import { Topology, type TopologyEvents } from './sdam/topology';
 import { ClientSession, type ClientSessionOptions, ServerSessionPool } from './sessions';
@@ -318,6 +319,12 @@ export interface MongoClientOptions extends BSONSerializeOptions, SupportedNodeC
   connectionType?: typeof Connection;
   /** @internal */
   __skipPingOnConnect?: boolean;
+  /**
+   * @experimental
+   *
+   * If provided, any adapters provided will be used in place of the corresponding Node.js module.
+   */
+  runtimeAdapters?: RuntimeAdapters;
 }
 
 /** @public */
@@ -789,7 +796,7 @@ export class MongoClient extends TypedEventEmitter<MongoClientEvents> implements
       // to avoid the server selection timeout.
       const selector = readPreferenceServerSelector(ReadPreference.primaryPreferred);
       const serverDescriptions = Array.from(topologyDescription.servers.values());
-      const servers = selector(topologyDescription, serverDescriptions);
+      const servers = selector(topologyDescription, serverDescriptions, new DeprioritizedServers());
       if (servers.length !== 0) {
         const endSessions = Array.from(client.s.sessionPool.sessions, ({ id }) => id);
         if (endSessions.length !== 0) {
@@ -1152,4 +1159,7 @@ export interface MongoOptions
   timeoutMS?: number;
   /** @internal */
   __skipPingOnConnect?: boolean;
+
+  /** @internal */
+  runtime: Runtime;
 }

package/src/mongo_logger.ts

@@ -1,4 +1,5 @@
-import { inspect, promisify } from 'util';
+import * as process from 'process';
+import { inspect } from 'util';
 
 import {
   type Binary,
@@ -240,11 +241,15 @@ export function createStdioLogger(stream: {
   write: NodeJS.WriteStream['write'];
 }): MongoDBLogWritable {
   return {
-    write: promisify((log: Log, cb: (error?: Error | null) => void): unknown => {
-      const logLine = inspect(log, { compact: true, breakLength: Infinity });
-      stream.write(`${logLine}\n`, 'utf-8', cb);
-      return;
-    })
+    write: (log: Log): Promise<unknown> => {
+      return new Promise((resolve, reject) => {
+        const logLine = inspect(log, { compact: true, breakLength: Infinity });
+        stream.write(`${logLine}\n`, 'utf-8', error => {
+          if (error) return reject(error);
+          resolve(true);
+        });
+      });
+    }
   };
 }
 

package/src/operations/execute_operation.ts

@@ -17,8 +17,8 @@ import {
 } from '../error';
 import type { MongoClient } from '../mongo_client';
 import { ReadPreference } from '../read_preference';
-import type { ServerDescription } from '../sdam/server_description';
 import {
+  DeprioritizedServers,
   sameServerSelector,
   secondaryWritableServerSelector,
   type ServerSelector
@@ -207,7 +207,8 @@ async function tryOperation<T extends AbstractOperation, TResult = ResultTypeFro
     session,
     operationName: operation.commandName,
     timeoutContext,
-    signal: operation.options.signal
+    signal: operation.options.signal,
+    deprioritizedServers: new DeprioritizedServers()
   });
 
   const hasReadAspect = operation.hasAspect(Aspect.READ_OPERATION);
@@ -234,7 +235,7 @@ async function tryOperation<T extends AbstractOperation, TResult = ResultTypeFro
 
   const maxTries = willRetry ? (timeoutContext.csotEnabled() ? Infinity : 2) : 1;
   let previousOperationError: MongoError | undefined;
-  let previousServer: ServerDescription | undefined;
+  const deprioritizedServers = new DeprioritizedServers();
 
   for (let tries = 0; tries < maxTries; tries++) {
     if (previousOperationError) {
@@ -270,7 +271,7 @@ async function tryOperation<T extends AbstractOperation, TResult = ResultTypeFro
       server = await topology.selectServer(selector, {
         session,
         operationName: operation.commandName,
-        previousServer,
+        deprioritizedServers,
         signal: operation.options.signal
       });
 
@@ -303,7 +304,7 @@ async function tryOperation<T extends AbstractOperation, TResult = ResultTypeFro
       ) {
         throw previousOperationError;
       }
-      previousServer = server.description;
+      deprioritizedServers.add(server.description);
       previousOperationError = operationError;
 
       // Reset timeouts

package/src/operations/rename.ts

@@ -11,7 +11,12 @@ import { Aspect, defineAspects } from './operation';
 export interface RenameOptions extends Omit<CommandOperationOptions, 'rawData'> {
   /** Drop the target name collection if it previously exists. */
   dropTarget?: boolean;
-  /** Unclear */
+  /**
+   * @deprecated
+   *
+   * This option has been dead code since at least Node driver version 4.x. It will
+   * be removed in a future major release.
+   */
   new_collection?: boolean;
 }
 

package/src/runtime_adapters.ts

@@ -0,0 +1,49 @@
+/* eslint-disable no-restricted-imports, @typescript-eslint/no-require-imports */
+
+// We squash the restricted import errors here because we are using type-only imports, which
+// do not impact the driver's actual runtime dependencies.
+// We also allow restricted imports in this file, because we expect this file to be the only place actually importing restricted Node APIs.
+
+import type * as os from 'os';
+
+import { type MongoClientOptions } from './mongo_client';
+
+/**
+ * @public
+ * @experimental
+ *
+ * Represents the set of dependencies that the driver uses from the [Node.js OS module](https://nodejs.org/api/os.html).
+ */
+export type OsAdapter = Pick<typeof os, 'release' | 'platform' | 'arch' | 'type'>;
+
+/**
+ * @public
+ * @experimental
+ *
+ * This type represents the set of dependencies that the driver needs from the Javascript runtime in order to function.
+ */
+export interface RuntimeAdapters {
+  os?: OsAdapter;
+}
+
+/**
+ * @internal
+ *
+ * Represents a complete, parsed set of runtime adapters.  After options parsing, all adapters
+ * are always present (either using the user's provided adapter, or defaulting to the Node.js module).
+ */
+export interface Runtime {
+  os: OsAdapter;
+}
+
+/**
+ * @internal
+ *
+ * Given a MongoClientOptions, this function resolves the set of runtime options, providing Nodejs implementations if
+ * not provided by in `options`, and returns a `Runtime`.
+ */
+export function resolveRuntimeAdapters(options: MongoClientOptions): Runtime {
+  return {
+    os: options.runtimeAdapters?.os ?? require('os')
+  };
+}