mongodb 7.1.1 → 7.2.0

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, NumberUtils } from '../../bson';
+import { BSON, ByteUtils, 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,16 +107,16 @@ type MakeClientMetadataOptions = Pick<MongoOptions, 'appName'>;
  */
 export async function makeClientMetadata(
   driverInfoList: DriverInfo[],
-  { appName = '' }: MakeClientMetadataOptions
+  { appName = '', runtime: { os } }: MakeClientMetadataOptions
 ): Promise<ClientMetadata> {
   const metadataDocument = new LimitedSizeDocument(512);
 
   // Add app name first, it must be sent
   if (appName.length > 0) {
     const name =
-      Buffer.byteLength(appName, 'utf8') <= 128
+      ByteUtils.utf8ByteLength(appName) <= 128
         ? appName
-        : Buffer.from(appName, 'utf8').subarray(0, 128).toString('utf8');
+        : ByteUtils.toUTF8(ByteUtils.fromUTF8(appName), 0, 128, false);
     metadataDocument.ifItFitsItSits('application', { name });
   }
 

package/src/cmap/wire_protocol/compression.ts

@@ -1,5 +1,6 @@
 import * as zlib from 'zlib';
 
+import { ByteUtils, readInt32LE } from '../../bson';
 import { LEGACY_HELLO_COMMAND } from '../../constants';
 import { getSnappy, getZstdLibrary, type SnappyLib, type ZStandard } from '../../deps';
 import { MongoDecompressionError, MongoInvalidArgumentError } from '../../error';
@@ -43,7 +44,7 @@ export const uncompressibleCommands = new Set([
 const ZSTD_COMPRESSION_LEVEL = 3;
 
 const zlibInflate = (buf: zlib.InputType) => {
-  return new Promise<Buffer>((resolve, reject) => {
+  return new Promise<Uint8Array>((resolve, reject) => {
     zlib.inflate(buf, (error, result) => {
       if (error) return reject(error);
       resolve(result);
@@ -52,7 +53,7 @@ const zlibInflate = (buf: zlib.InputType) => {
 };
 
 const zlibDeflate = (buf: zlib.InputType, options: zlib.ZlibOptions) => {
-  return new Promise<Buffer>((resolve, reject) => {
+  return new Promise<Uint8Array>((resolve, reject) => {
     zlib.deflate(buf, options, (error, result) => {
       if (error) return reject(error);
       resolve(result);
@@ -76,8 +77,8 @@ function loadSnappy() {
 // Facilitate compressing a message using an agreed compressor
 export async function compress(
   options: OpCompressesRequestOptions,
-  dataToBeCompressed: Buffer
-): Promise<Buffer> {
+  dataToBeCompressed: Uint8Array
+): Promise<Uint8Array> {
   const zlibOptions = {} as zlib.ZlibOptions;
   switch (options.agreedCompressor) {
     case 'snappy': {
@@ -106,7 +107,10 @@ export async function compress(
 }
 
 // Decompress a message using the given compressor
-export async function decompress(compressorID: number, compressedData: Buffer): Promise<Buffer> {
+export async function decompress(
+  compressorID: number,
+  compressedData: Uint8Array
+): Promise<Uint8Array> {
   if (
     compressorID !== Compressor.snappy &&
     compressorID !== Compressor.zstd &&
@@ -159,7 +163,7 @@ const MESSAGE_HEADER_SIZE = 16;
 export async function compressCommand(
   command: WriteProtocolMessageType,
   description: { agreedCompressor?: CompressorName; zlibCompressionLevel?: number }
-): Promise<Buffer> {
+): Promise<Uint8Array> {
   const finalCommand =
     description.agreedCompressor === 'none' || !OpCompressedRequest.canCompress(command)
       ? command
@@ -168,7 +172,7 @@ export async function compressCommand(
           zlibCompressionLevel: description.zlibCompressionLevel ?? 0
         });
   const data = await finalCommand.toBin();
-  return Buffer.concat(data);
+  return ByteUtils.concat(data);
 }
 
 /**
@@ -178,12 +182,12 @@ export async function compressCommand(
  *
  * This method does not parse the response's BSON.
  */
-export async function decompressResponse(message: Buffer): Promise<OpMsgResponse | OpReply> {
+export async function decompressResponse(message: Uint8Array): Promise<OpMsgResponse | OpReply> {
   const messageHeader: MessageHeader = {
-    length: message.readInt32LE(0),
-    requestId: message.readInt32LE(4),
-    responseTo: message.readInt32LE(8),
-    opCode: message.readInt32LE(12)
+    length: readInt32LE(message, 0),
+    requestId: readInt32LE(message, 4),
+    responseTo: readInt32LE(message, 8),
+    opCode: readInt32LE(message, 12)
   };
 
   if (messageHeader.opCode !== OP_COMPRESSED) {
@@ -195,8 +199,8 @@ export async function decompressResponse(message: Buffer): Promise<OpMsgResponse
   const header: MessageHeader = {
     ...messageHeader,
     fromCompressed: true,
-    opCode: message.readInt32LE(MESSAGE_HEADER_SIZE),
-    length: message.readInt32LE(MESSAGE_HEADER_SIZE + 4)
+    opCode: readInt32LE(message, MESSAGE_HEADER_SIZE),
+    length: readInt32LE(message, MESSAGE_HEADER_SIZE + 4)
   };
   const compressorID = message[MESSAGE_HEADER_SIZE + 8];
   const compressedBuffer = message.slice(MESSAGE_HEADER_SIZE + 9);

package/src/cmap/wire_protocol/on_data.ts

@@ -9,7 +9,7 @@ import { addAbortListener, kDispose, List, promiseWithResolvers } from '../../ut
  * An object holding references to a promise's resolve and reject functions.
  */
 type PendingPromises = Omit<
-  ReturnType<typeof promiseWithResolvers<IteratorResult<Buffer>>>,
+  ReturnType<typeof promiseWithResolvers<IteratorResult<Uint8Array>>>,
   'promise'
 >;
 
@@ -32,7 +32,7 @@ export function onData(
    * value from the event in this list. Next time they call .next()
    * we pull the first value out of this list and resolve a promise with it.
    */
-  const unconsumedEvents = new List<Buffer>();
+  const unconsumedEvents = new List<Uint8Array>();
   /**
    * When there has not yet been an event, a new promise will be created
    * and implicitly stored in this list. When an event occurs we take the first
@@ -49,7 +49,7 @@ export function onData(
   /** Set to true only after event listeners have been removed. */
   let finished = false;
 
-  const iterator: AsyncGenerator<Buffer> & AsyncDisposable = {
+  const iterator: AsyncGenerator<Uint8Array> & AsyncDisposable = {
     next() {
       // First, we consume all unread events
       const value = unconsumedEvents.shift();
@@ -71,7 +71,7 @@ export function onData(
       if (finished) return closeHandler();
 
       // Wait until an event happens
-      const { promise, resolve, reject } = promiseWithResolvers<IteratorResult<Buffer>>();
+      const { promise, resolve, reject } = promiseWithResolvers<IteratorResult<Uint8Array>>();
       unconsumedPromises.push({ resolve, reject });
       return promise;
     },
@@ -107,7 +107,7 @@ export function onData(
 
   return iterator;
 
-  function eventHandler(value: Buffer) {
+  function eventHandler(value: Uint8Array) {
     const promise = unconsumedPromises.shift();
     if (promise != null) promise.resolve({ value, done: false });
     else unconsumedEvents.push(value);

package/src/cmap/wire_protocol/on_demand/document.ts

@@ -3,15 +3,13 @@ import {
   type BSONElement,
   BSONError,
   BSONType,
+  ByteUtils,
   deserialize,
   type DeserializeOptions,
-  getBigInt64LE,
-  getFloat64LE,
-  getInt32LE,
+  NumberUtils,
   ObjectId,
   parseToElementsToArray,
-  Timestamp,
-  toUTF8
+  Timestamp
 } from '../../../bson';
 
 const BSONElementOffset = {
@@ -183,25 +181,25 @@ export class OnDemandDocument {
       case BSONType.undefined:
         return null;
       case BSONType.double:
-        return getFloat64LE(this.bson, offset);
+        return NumberUtils.getFloat64LE(this.bson, offset);
       case BSONType.int:
-        return getInt32LE(this.bson, offset);
+        return NumberUtils.getInt32LE(this.bson, offset);
       case BSONType.long:
-        return getBigInt64LE(this.bson, offset);
+        return NumberUtils.getBigInt64LE(this.bson, offset);
       case BSONType.bool:
         return Boolean(this.bson[offset]);
       case BSONType.objectId:
         return new ObjectId(this.bson.subarray(offset, offset + 12));
       case BSONType.timestamp:
-        return new Timestamp(getBigInt64LE(this.bson, offset));
+        return new Timestamp(NumberUtils.getBigInt64LE(this.bson, offset));
       case BSONType.string:
-        return toUTF8(this.bson, offset + 4, offset + length - 1, false);
+        return ByteUtils.toUTF8(this.bson, offset + 4, offset + length - 1, false);
       case BSONType.binData: {
-        const totalBinarySize = getInt32LE(this.bson, offset);
+        const totalBinarySize = NumberUtils.getInt32LE(this.bson, offset);
         const subType = this.bson[offset + 4];
 
         if (subType === 2) {
-          const subType2BinarySize = getInt32LE(this.bson, offset + 1 + 4);
+          const subType2BinarySize = NumberUtils.getInt32LE(this.bson, offset + 1 + 4);
           if (subType2BinarySize < 0)
             throw new BSONError('Negative binary type element size found for subtype 0x02');
           if (subType2BinarySize > totalBinarySize - 4)
@@ -221,7 +219,7 @@ export class OnDemandDocument {
       }
       case BSONType.date:
         // Pretend this is correct.
-        return new Date(Number(getBigInt64LE(this.bson, offset)));
+        return new Date(Number(NumberUtils.getBigInt64LE(this.bson, offset)));
 
       case BSONType.object:
         return new OnDemandDocument(this.bson, offset);
@@ -352,7 +350,7 @@ export class OnDemandDocument {
 
   /** Returns this document's bytes only */
   toBytes() {
-    const size = getInt32LE(this.bson, this.offset);
+    const size = NumberUtils.getInt32LE(this.bson, this.offset);
     return this.bson.subarray(this.offset, this.offset + size);
   }
 }

package/src/connection_string.ts

@@ -20,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 {
@@ -41,17 +42,21 @@ const LB_REPLICA_SET_ERROR = 'loadBalanced option not supported with a replicaSe
 const LB_DIRECT_CONNECTION_ERROR =
   'loadBalanced option not supported when directConnection is provided';
 
-function retryDNSTimeoutFor(api: 'resolveSrv'): (a: string) => Promise<dns.SrvRecord[]>;
-function retryDNSTimeoutFor(api: 'resolveTxt'): (a: string) => Promise<string[][]>;
+function retryDNSTimeoutFor(rrtype: 'SRV'): (lookupAddress: string) => Promise<dns.SrvRecord[]>;
+function retryDNSTimeoutFor(rrtype: 'TXT'): (lookupAddress: string) => Promise<string[][]>;
 function retryDNSTimeoutFor(
-  api: 'resolveSrv' | 'resolveTxt'
-): (a: string) => Promise<dns.SrvRecord[] | string[][]> {
+  rrtype: 'SRV' | 'TXT'
+): (lookupAddress: string) => Promise<dns.SrvRecord[] | string[][]> {
+  const resolve =
+    rrtype === 'SRV'
+      ? (address: string) => dns.promises.resolve(address, 'SRV')
+      : (address: string) => dns.promises.resolve(address, 'TXT');
   return async function dnsReqRetryTimeout(lookupAddress: string) {
     try {
-      return await dns.promises[api](lookupAddress);
+      return await resolve(lookupAddress);
     } catch (firstDNSError) {
       if (firstDNSError.code === dns.TIMEOUT) {
-        return await dns.promises[api](lookupAddress);
+        return await resolve(lookupAddress);
       } else {
         throw firstDNSError;
       }
@@ -59,8 +64,8 @@ function retryDNSTimeoutFor(
   };
 }
 
-const resolveSrv = retryDNSTimeoutFor('resolveSrv');
-const resolveTxt = retryDNSTimeoutFor('resolveTxt');
+const resolveSrv = retryDNSTimeoutFor('SRV');
+const resolveTxt = retryDNSTimeoutFor('TXT');
 
 /**
  * Lookup a `mongodb+srv` connection string, combine the parts and reparse it as a normal
@@ -538,6 +543,8 @@ export function parseOptions(
     }
   );
 
+  mongoOptions.runtime = resolveRuntimeAdapters(options);
+
   return mongoOptions;
 }
 
@@ -636,6 +643,10 @@ interface OptionDescriptor {
 }
 
 export const OPTIONS = {
+  enableOverloadRetargeting: {
+    default: false,
+    type: 'boolean'
+  },
   appName: {
     type: 'string'
   },
@@ -874,6 +885,10 @@ export const OPTIONS = {
     default: 15,
     type: 'uint'
   },
+  maxAdaptiveRetries: {
+    default: 2,
+    type: 'uint'
+  },
   maxConnecting: {
     default: 2,
     transform({ name, values: [value] }): number {
@@ -1061,6 +1076,9 @@ export const OPTIONS = {
     default: true,
     type: 'boolean'
   },
+  runtimeAdapters: {
+    type: 'record'
+  },
   serializeFunctions: {
     type: 'boolean'
   },

package/src/deps.ts

@@ -50,12 +50,12 @@ type ZStandardLib = {
    * Compress using zstd.
    * @param buf - Buffer to be compressed.
    */
-  compress(buf: Buffer, level?: number): Promise<Buffer>;
+  compress(buf: Uint8Array, level?: number): Promise<Uint8Array>;
 
   /**
    * Decompress using zstd.
    */
-  decompress(buf: Buffer): Promise<Buffer>;
+  decompress(buf: Uint8Array): Promise<Uint8Array>;
 };
 
 export type ZStandard = ZStandardLib | { kModuleError: MongoMissingDependencyError };
@@ -144,13 +144,13 @@ export type SnappyLib = {
    * In order to support both we must check the return value of the function
    * @param buf - Buffer to be compressed
    */
-  compress(buf: Buffer): Promise<Buffer>;
+  compress(buf: Uint8Array): Promise<Uint8Array>;
 
   /**
    * In order to support both we must check the return value of the function
    * @param buf - Buffer to be compressed
    */
-  uncompress(buf: Buffer, opt: { asBuffer: true }): Promise<Buffer>;
+  uncompress(buf: Uint8Array, opt: { asBuffer: true }): Promise<Uint8Array>;
 };
 
 export function getSnappy(): SnappyLib | { kModuleError: MongoMissingDependencyError } {

package/src/gridfs/download.ts

@@ -1,6 +1,6 @@
 import { Readable } from 'stream';
 
-import type { Document, ObjectId } from '../bson';
+import { ByteUtils, type Document, type ObjectId } from '../bson';
 import type { Collection } from '../collection';
 import { CursorTimeoutMode } from '../cursor/abstract_cursor';
 import type { FindCursor } from '../cursor/find_cursor';
@@ -248,7 +248,7 @@ function doRead(stream: GridFSBucketReadStream): void {
       );
     }
 
-    let buf = Buffer.isBuffer(doc.data) ? doc.data : doc.data.buffer;
+    let buf = ByteUtils.isUint8Array(doc.data) ? doc.data : doc.data.buffer;
 
     if (buf.byteLength !== expectedLength) {
       if (bytesRemaining <= 0) {

package/src/gridfs/upload.ts

@@ -1,6 +1,6 @@
 import { Writable } from 'stream';
 
-import { type Document, ObjectId } from '../bson';
+import { ByteUtils, type Document, ObjectId } from '../bson';
 import type { Collection } from '../collection';
 import { CursorTimeoutMode } from '../cursor/abstract_cursor';
 import {
@@ -62,7 +62,7 @@ export class GridFSBucketWriteStream extends Writable {
   /** The number of bytes that each chunk will be limited to */
   chunkSizeBytes: number;
   /** Space used to store a chunk currently being inserted */
-  bufToStore: Buffer;
+  bufToStore: Uint8Array;
   /** Accumulates the number of bytes inserted as the stream uploads chunks */
   length: number;
   /** Accumulates the number of chunks inserted as the stream uploads file contents */
@@ -122,7 +122,7 @@ export class GridFSBucketWriteStream extends Writable {
     this.id = options.id ? options.id : new ObjectId();
     // properly inherit the default chunksize from parent
     this.chunkSizeBytes = options.chunkSizeBytes || this.bucket.s.options.chunkSizeBytes;
-    this.bufToStore = Buffer.alloc(this.chunkSizeBytes);
+    this.bufToStore = ByteUtils.allocate(this.chunkSizeBytes);
     this.length = 0;
     this.n = 0;
     this.pos = 0;
@@ -178,7 +178,7 @@ export class GridFSBucketWriteStream extends Writable {
    * @param callback - Function to call when the chunk was added to the buffer, or if the entire chunk was persisted to MongoDB if this chunk caused a flush.
    */
   override _write(
-    chunk: Buffer | string,
+    chunk: Uint8Array | string,
     encoding: BufferEncoding,
     callback: Callback<void>
   ): void {
@@ -227,7 +227,7 @@ function handleError(stream: GridFSBucketWriteStream, error: Error, callback: Ca
   queueMicrotask(() => callback(error));
 }
 
-function createChunkDoc(filesId: ObjectId, n: number, data: Buffer): GridFSChunk {
+function createChunkDoc(filesId: ObjectId, n: number, data: Uint8Array): GridFSChunk {
   return {
     _id: new ObjectId(),
     files_id: filesId,
@@ -409,7 +409,7 @@ function createFilesDoc(
 
 function doWrite(
   stream: GridFSBucketWriteStream,
-  chunk: Buffer | string,
+  chunk: Uint8Array | string,
   encoding: BufferEncoding,
   callback: Callback<void>
 ): void {
@@ -417,13 +417,14 @@ function doWrite(
     return;
   }
 
-  const inputBuf = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk, encoding);
+  const inputBuf =
+    typeof chunk === 'string' ? ByteUtils.fromUTF8(chunk) : ByteUtils.toLocalBufferType(chunk);
 
   stream.length += inputBuf.length;
 
   // Input is small enough to fit in our buffer
   if (stream.pos + inputBuf.length < stream.chunkSizeBytes) {
-    inputBuf.copy(stream.bufToStore, stream.pos);
+    ByteUtils.copy(inputBuf, stream.bufToStore, stream.pos);
     stream.pos += inputBuf.length;
     queueMicrotask(callback);
     return;
@@ -437,12 +438,12 @@ function doWrite(
   let outstandingRequests = 0;
   while (inputBufRemaining > 0) {
     const inputBufPos = inputBuf.length - inputBufRemaining;
-    inputBuf.copy(stream.bufToStore, stream.pos, inputBufPos, inputBufPos + numToCopy);
+    ByteUtils.copy(inputBuf, stream.bufToStore, stream.pos, inputBufPos, inputBufPos + numToCopy);
     stream.pos += numToCopy;
     spaceRemaining -= numToCopy;
     let doc: GridFSChunk;
     if (spaceRemaining === 0) {
-      doc = createChunkDoc(stream.id, stream.n, Buffer.from(stream.bufToStore));
+      doc = createChunkDoc(stream.id, stream.n, new Uint8Array(stream.bufToStore));
 
       const remainingTimeMS = stream.timeoutContext?.remainingTimeMS;
       if (remainingTimeMS != null && remainingTimeMS <= 0) {
@@ -495,8 +496,8 @@ function writeRemnant(stream: GridFSBucketWriteStream, callback: Callback): void
 
   // Create a new buffer to make sure the buffer isn't bigger than it needs
   // to be.
-  const remnant = Buffer.alloc(stream.pos);
-  stream.bufToStore.copy(remnant, 0, 0, stream.pos);
+  const remnant = ByteUtils.allocate(stream.pos);
+  ByteUtils.copy(stream.bufToStore, remnant, 0, 0, stream.pos);
   const doc = createChunkDoc(stream.id, stream.n, remnant);
 
   // If the stream was aborted, do not write remnant

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,

package/src/mongo_client.ts

@@ -46,6 +46,7 @@ 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 { DeprioritizedServers, readPreferenceServerSelector } from './sdam/server_selection';
@@ -228,6 +229,18 @@ export interface MongoClientOptions extends BSONSerializeOptions, SupportedNodeC
   retryReads?: boolean;
   /** Enable retryable writes. */
   retryWrites?: boolean;
+  /**
+   * The maximum number of retries during server overload. Set to 0 to disable overload retries. Defaults to 2.
+   * @see https://www.mongodb.com/docs/atlas/overload-errors
+   * */
+  maxAdaptiveRetries?: number;
+  /**
+   * Whether or not to enable overload retargeting. Defaults to false.
+   * @see https://www.mongodb.com/docs/atlas/overload-errors
+   * More information about the overload policy in drivers:
+   * @see https://github.com/mongodb/specifications/blob/master/source/client-backpressure/client-backpressure.md#overload-retry-policy
+   * */
+  enableOverloadRetargeting?: boolean;
   /** Allow a driver to force a Single topology type with a connection string containing one host */
   directConnection?: boolean;
   /** Instruct the driver it is connecting to a load balancer fronting a mongos like service */
@@ -318,6 +331,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 */
@@ -1034,6 +1053,8 @@ export interface MongoOptions
   extends Required<
       Pick<
         MongoClientOptions,
+        | 'maxAdaptiveRetries'
+        | 'enableOverloadRetargeting'
         | 'autoEncryption'
         | 'connectTimeoutMS'
         | 'directConnection'
@@ -1152,4 +1173,7 @@ export interface MongoOptions
   timeoutMS?: number;
   /** @internal */
   __skipPingOnConnect?: boolean;
+
+  /** @internal */
+  runtime: Runtime;
 }

package/src/operations/client_bulk_write/command_builder.ts

@@ -242,7 +242,7 @@ function validateBufferSize(name: string, buffer: Uint8Array, maxBsonObjectSize:
 }
 
 /** @internal */
-interface ClientInsertOperation {
+export interface ClientInsertOperation {
   insert: number;
   document: OptionalId<Document>;
 }