mongodb 6.17.0-dev.20250604.sha.441186ae → 6.17.0-dev.20250605.sha.57ef31be

package/src/cmap/commands.ts

@@ -76,12 +76,10 @@ export class OpQueryRequest {
   partial: boolean;
   /** moreToCome is an OP_MSG only concept */
   moreToCome = false;
+  databaseName: string;
+  query: Document;
 
-  constructor(
-    public databaseName: string,
-    public query: Document,
-    options: OpQueryOptions
-  ) {
+  constructor(databaseName: string, query: Document, options: OpQueryOptions) {
     // Basic options needed to be passed in
     // TODO(NODE-3483): Replace with MongoCommandError
     const ns = `${databaseName}.$cmd`;
@@ -97,7 +95,9 @@ export class OpQueryRequest {
       throw new MongoRuntimeError('Namespace cannot contain a null character');
     }
 
-    // Basic options
+    // Basic optionsa
+    this.databaseName = databaseName;
+    this.query = query;
     this.ns = ns;
 
     // Additional options
@@ -496,17 +496,18 @@ export class OpMsgRequest {
   checksumPresent: boolean;
   moreToCome: boolean;
   exhaustAllowed: boolean;
+  databaseName: string;
+  command: Document;
+  options: OpQueryOptions;
 
-  constructor(
-    public databaseName: string,
-    public command: Document,
-    public options: OpQueryOptions
-  ) {
+  constructor(databaseName: string, command: Document, options: OpQueryOptions) {
     // Basic options needed to be passed in
     if (command == null)
       throw new MongoInvalidArgumentError('Query document must be specified for query');
 
-    // Basic options
+    // Basic optionsa
+    this.databaseName = databaseName;
+    this.command = command;
     this.command.$db = databaseName;
 
     // Ensure empty options
@@ -724,16 +725,30 @@ export class OpMsgResponse {
 const MESSAGE_HEADER_SIZE = 16;
 const COMPRESSION_DETAILS_SIZE = 9; // originalOpcode + uncompressedSize, compressorID
 
+/**
+ * @internal
+ */
+export interface OpCompressesRequestOptions {
+  zlibCompressionLevel: number;
+  agreedCompressor: CompressorName;
+}
+
 /**
  * @internal
  *
  * An OP_COMPRESSED request wraps either an OP_QUERY or OP_MSG message.
  */
 export class OpCompressedRequest {
-  constructor(
-    private command: WriteProtocolMessageType,
-    private options: { zlibCompressionLevel: number; agreedCompressor: CompressorName }
-  ) {}
+  private command: WriteProtocolMessageType;
+  private options: OpCompressesRequestOptions;
+
+  constructor(command: WriteProtocolMessageType, options: OpCompressesRequestOptions) {
+    this.command = command;
+    this.options = {
+      zlibCompressionLevel: options.zlibCompressionLevel,
+      agreedCompressor: options.agreedCompressor
+    };
+  }
 
   // Return whether a command contains an uncompressible command term
   // Will return true if command contains no uncompressible command terms

package/src/cmap/handshake/client_metadata.ts

@@ -53,7 +53,11 @@ export class LimitedSizeDocument {
   private document = new Map();
   /** BSON overhead: Int32 + Null byte */
   private documentSize = 5;
-  constructor(private maxSize: number) {}
+  private maxSize: number;
+
+  constructor(maxSize: number) {
+    this.maxSize = maxSize;
+  }
 
   /** Only adds key/value if the bsonByteLength is less than MAX_SIZE */
   public ifItFitsItSits(key: string, value: Record<string, any> | string): boolean {

package/src/cmap/wire_protocol/compression.ts

@@ -7,6 +7,7 @@ import { MongoDecompressionError, MongoInvalidArgumentError } from '../../error'
 import {
   type MessageHeader,
   OpCompressedRequest,
+  type OpCompressesRequestOptions,
   OpMsgResponse,
   OpReply,
   type WriteProtocolMessageType
@@ -60,7 +61,7 @@ function loadSnappy() {
 
 // Facilitate compressing a message using an agreed compressor
 export async function compress(
-  options: { zlibCompressionLevel: number; agreedCompressor: CompressorName },
+  options: OpCompressesRequestOptions,
   dataToBeCompressed: Buffer
 ): Promise<Buffer> {
   const zlibOptions = {} as zlib.ZlibOptions;

package/src/cmap/wire_protocol/on_data.ts

@@ -87,6 +87,11 @@ export function onData(
 
     [Symbol.asyncIterator]() {
       return this;
+    },
+
+    // Note this should currently not be used, but is required by the AsyncGenerator interface.
+    async [Symbol.asyncDispose]() {
+      await closeHandler();
     }
   };
 

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

@@ -14,14 +14,13 @@ import {
   toUTF8
 } from '../../../bson';
 
-// eslint-disable-next-line no-restricted-syntax
-const enum BSONElementOffset {
-  type = 0,
-  nameOffset = 1,
-  nameLength = 2,
-  offset = 3,
-  length = 4
-}
+const BSONElementOffset = {
+  type: 0,
+  nameOffset: 1,
+  nameLength: 2,
+  offset: 3,
+  length: 4
+} as const;
 
 /** @internal */
 export type JSTypeOf = {
@@ -67,17 +66,23 @@ export class OnDemandDocument {
 
   /** All bson elements in this document */
   private readonly elements: ReadonlyArray<BSONElement>;
+  /** BSON bytes, this document begins at offset */
+  protected readonly bson: Uint8Array;
+  /** The start of the document */
+  private readonly offset: number;
+  /** If this is an embedded document, indicates if this was a BSON array */
+  public readonly isArray: boolean;
 
   constructor(
-    /** BSON bytes, this document begins at offset */
-    protected readonly bson: Uint8Array,
-    /** The start of the document */
-    private readonly offset = 0,
-    /** If this is an embedded document, indicates if this was a BSON array */
-    public readonly isArray = false,
+    bson: Uint8Array,
+    offset = 0,
+    isArray = false,
     /** If elements was already calculated */
     elements?: BSONElement[]
   ) {
+    this.bson = bson;
+    this.offset = offset;
+    this.isArray = isArray;
     this.elements = elements ?? parseToElementsToArray(this.bson, offset);
   }
 

package/src/cmap/wire_protocol/responses.ts

@@ -20,14 +20,14 @@ import {
   type OnDemandDocumentDeserializeOptions
 } from './on_demand/document';
 
-// eslint-disable-next-line no-restricted-syntax
-const enum BSONElementOffset {
-  type = 0,
-  nameOffset = 1,
-  nameLength = 2,
-  offset = 3,
-  length = 4
-}
+const BSONElementOffset = {
+  type: 0,
+  nameOffset: 1,
+  nameLength: 2,
+  offset: 3,
+  length: 4
+} as const;
+
 /**
  * Accepts a BSON payload and checks for na "ok: 0" element.
  * This utility is intended to prevent calling response class constructors

package/src/connection_string.ts

@@ -605,6 +605,8 @@ function setOption(
       if (values[0] == null) {
         break;
       }
+      // The value should always be a string here, but since the array is typed as unknown
+      // there still needs to be an explicit cast.
       // eslint-disable-next-line @typescript-eslint/no-base-to-string
       mongoOptions[name] = String(values[0]);
       break;

package/src/cursor/abstract_cursor.ts

@@ -1213,11 +1213,13 @@ configureResourceManagement(AbstractCursor.prototype);
  * All timeout behavior is exactly the same as the wrapped timeout context's.
  */
 export class CursorTimeoutContext extends TimeoutContext {
-  constructor(
-    public timeoutContext: TimeoutContext,
-    public owner: symbol | AbstractCursor
-  ) {
+  timeoutContext: TimeoutContext;
+  owner: symbol | AbstractCursor;
+
+  constructor(timeoutContext: TimeoutContext, owner: symbol | AbstractCursor) {
     super();
+    this.timeoutContext = timeoutContext;
+    this.owner = owner;
   }
   override get serverSelectionTimeout(): Timeout | null {
     return this.timeoutContext.serverSelectionTimeout;

package/src/index.ts

@@ -208,6 +208,7 @@ export type {
   ChangeStreamDocumentCommon,
   ChangeStreamDocumentKey,
   ChangeStreamDocumentOperationDescription,
+  ChangeStreamDocumentWallTime,
   ChangeStreamDropDatabaseDocument,
   ChangeStreamDropDocument,
   ChangeStreamDropIndexDocument,
@@ -287,6 +288,7 @@ export type { TokenCache } from './cmap/auth/mongodb_oidc/token_cache';
 export type {
   MessageHeader,
   OpCompressedRequest,
+  OpCompressesRequestOptions,
   OpMsgOptions,
   OpMsgRequest,
   OpMsgResponse,

package/src/operations/distinct.ts

@@ -96,6 +96,7 @@ export class DistinctOperation extends CommandOperation<any[]> {
 
     const result = await super.executeCommand(server, session, cmd, timeoutContext);
 
+    // @ts-expect-error: Explain always returns a document
     return this.explain ? result : result.values;
   }
 }

package/src/operations/rename.ts

@@ -17,12 +17,15 @@ export interface RenameOptions extends CommandOperationOptions {
 
 /** @internal */
 export class RenameOperation extends CommandOperation<Document> {
-  constructor(
-    public collection: Collection,
-    public newName: string,
-    public override options: RenameOptions
-  ) {
+  collection: Collection;
+  newName: string;
+  override options: RenameOptions;
+
+  constructor(collection: Collection, newName: string, options: RenameOptions) {
     super(collection, options);
+    this.collection = collection;
+    this.newName = newName;
+    this.options = options;
     this.ns = new MongoDBNamespace('admin', '$cmd');
   }
 

package/src/operations/run_command.ts

@@ -26,12 +26,17 @@ export type RunCommandOptions = {
 
 /** @internal */
 export class RunCommandOperation<T = Document> extends AbstractOperation<T> {
+  command: Document;
+  override options: RunCommandOptions & { responseType?: MongoDBResponseConstructor };
+
   constructor(
     parent: Db,
-    public command: Document,
-    public override options: RunCommandOptions & { responseType?: MongoDBResponseConstructor }
+    command: Document,
+    options: RunCommandOptions & { responseType?: MongoDBResponseConstructor }
   ) {
     super(options);
+    this.command = command;
+    this.options = options;
     this.ns = parent.s.namespace.withCollection('$cmd');
   }
 
@@ -62,14 +67,22 @@ export class RunCommandOperation<T = Document> extends AbstractOperation<T> {
 }
 
 export class RunAdminCommandOperation<T = Document> extends AbstractOperation<T> {
+  command: Document;
+  override options: RunCommandOptions & {
+    noResponse?: boolean;
+    bypassPinningCheck?: boolean;
+  };
+
   constructor(
-    public command: Document,
-    public override options: RunCommandOptions & {
+    command: Document,
+    options: RunCommandOptions & {
       noResponse?: boolean;
       bypassPinningCheck?: boolean;
     }
   ) {
     super(options);
+    this.command = command;
+    this.options = options;
     this.ns = new MongoDBNamespace('admin', '$cmd');
   }
 

package/src/operations/search_indexes/create.ts

@@ -21,11 +21,13 @@ export interface SearchIndexDescription extends Document {
 
 /** @internal */
 export class CreateSearchIndexesOperation extends AbstractOperation<string[]> {
-  constructor(
-    private readonly collection: Collection,
-    private readonly descriptions: ReadonlyArray<SearchIndexDescription>
-  ) {
+  private readonly collection: Collection;
+  private readonly descriptions: ReadonlyArray<SearchIndexDescription>;
+
+  constructor(collection: Collection, descriptions: ReadonlyArray<SearchIndexDescription>) {
     super();
+    this.collection = collection;
+    this.descriptions = descriptions;
   }
 
   override get commandName() {

package/src/operations/search_indexes/drop.ts

@@ -8,11 +8,13 @@ import { AbstractOperation } from '../operation';
 
 /** @internal */
 export class DropSearchIndexOperation extends AbstractOperation<void> {
-  constructor(
-    private readonly collection: Collection,
-    private readonly name: string
-  ) {
+  private readonly collection: Collection;
+  private readonly name: string;
+
+  constructor(collection: Collection, name: string) {
     super();
+    this.collection = collection;
+    this.name = name;
   }
 
   override get commandName() {

package/src/operations/search_indexes/update.ts

@@ -7,12 +7,15 @@ import { AbstractOperation } from '../operation';
 
 /** @internal */
 export class UpdateSearchIndexOperation extends AbstractOperation<void> {
-  constructor(
-    private readonly collection: Collection,
-    private readonly name: string,
-    private readonly definition: Document
-  ) {
+  private readonly collection: Collection;
+  private readonly name: string;
+  private readonly definition: Document;
+
+  constructor(collection: Collection, name: string, definition: Document) {
     super();
+    this.collection = collection;
+    this.name = name;
+    this.definition = definition;
   }
 
   override get commandName() {

package/src/utils.ts

@@ -281,16 +281,16 @@ export function ns(ns: string): MongoDBNamespace {
 
 /** @public */
 export class MongoDBNamespace {
+  db: string;
+  collection?: string;
   /**
    * Create a namespace object
    *
    * @param db - database name
    * @param collection - collection name
    */
-  constructor(
-    public db: string,
-    public collection?: string
-  ) {
+  constructor(db: string, collection?: string) {
+    this.db = db;
     this.collection = collection === '' ? undefined : collection;
   }
 
@@ -322,11 +322,11 @@ export class MongoDBNamespace {
  * used in scenarios where this can be guaranteed.
  */
 export class MongoDBCollectionNamespace extends MongoDBNamespace {
-  constructor(
-    db: string,
-    override collection: string
-  ) {
+  override collection: string;
+
+  constructor(db: string, collection: string) {
     super(db, collection);
+    this.collection = collection;
   }
 
   static override fromString(namespace?: string): MongoDBCollectionNamespace {

package/src/write_concern.ts

@@ -143,6 +143,7 @@ export class WriteConcern {
     const parentOpts: WriteConcern | WriteConcernSettings | undefined =
       inherit instanceof WriteConcern ? inherit : inherit.writeConcern;
 
+    const mergedOpts = { ...parentOpts, ...opts } as WriteConcernSettings;
     const {
       w = undefined,
       wtimeout = undefined,
@@ -150,10 +151,7 @@ export class WriteConcern {
       fsync = undefined,
       journal = undefined,
       wtimeoutMS = undefined
-    } = {
-      ...parentOpts,
-      ...opts
-    };
+    } = mergedOpts;
     if (
       w != null ||
       wtimeout != null ||

package/tsconfig.json

@@ -11,7 +11,8 @@
     "lib": [
       "es2021",
       "ES2022.Error",
-      "ES2022.Object"
+      "ES2022.Object",
+      "esnext.disposable"
     ],
     // We don't make use of tslib helpers, all syntax used is supported by target engine
     "importHelpers": false,