mongodb 6.11.0 → 6.12.0-dev.20241212.sha.f6d7868f

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mongodb",
-  "version": "6.11.0",
+  "version": "6.12.0-dev.20241212.sha.f6d7868f",
   "description": "The official MongoDB driver for Node.js",
   "main": "lib/index.js",
   "files": [
@@ -26,12 +26,12 @@
   },
   "dependencies": {
     "@mongodb-js/saslprep": "^1.1.9",
-    "bson": "^6.10.0",
+    "bson": "^6.10.1",
     "mongodb-connection-string-url": "^3.0.0"
   },
   "peerDependencies": {
     "@aws-sdk/credential-providers": "^3.188.0",
-    "@mongodb-js/zstd": "^1.1.0",
+    "@mongodb-js/zstd": "^1.1.0 || ^2.0.0",
     "gcp-metadata": "^5.2.0",
     "kerberos": "^2.0.1",
     "mongodb-client-encryption": ">=6.0.0 <7",
@@ -67,7 +67,7 @@
     "@istanbuljs/nyc-config-typescript": "^1.0.2",
     "@microsoft/api-extractor": "^7.47.11",
     "@microsoft/tsdoc-config": "^0.17.0",
-    "@mongodb-js/zstd": "^1.2.2",
+    "@mongodb-js/zstd": "^2.0.0",
     "@types/chai": "^4.3.17",
     "@types/chai-subset": "^1.3.5",
     "@types/express": "^4.17.21",
@@ -176,4 +176,4 @@
       "moduleResolution": "node"
     }
   }
-}
+}

package/src/bulk/common.ts

@@ -30,9 +30,6 @@ import {
 } from '../utils';
 import { WriteConcern } from '../write_concern';
 
-/** @internal */
-const kServerError = Symbol('serverError');
-
 /** @public */
 export const BatchType = Object.freeze({
   INSERT: 1,
@@ -315,29 +312,29 @@ export interface WriteConcernErrorData {
  */
 export class WriteConcernError {
   /** @internal */
-  [kServerError]: WriteConcernErrorData;
+  private serverError: WriteConcernErrorData;
 
   constructor(error: WriteConcernErrorData) {
-    this[kServerError] = error;
+    this.serverError = error;
   }
 
   /** Write concern error code. */
   get code(): number | undefined {
-    return this[kServerError].code;
+    return this.serverError.code;
   }
 
   /** Write concern error message. */
   get errmsg(): string | undefined {
-    return this[kServerError].errmsg;
+    return this.serverError.errmsg;
   }
 
   /** Write concern error info. */
   get errInfo(): Document | undefined {
-    return this[kServerError].errInfo;
+    return this.serverError.errInfo;
   }
 
   toJSON(): WriteConcernErrorData {
-    return this[kServerError];
+    return this.serverError;
   }
 
   toString(): string {

package/src/change_stream.ts

@@ -24,13 +24,6 @@ import type { ServerSessionId } from './sessions';
 import { CSOTTimeoutContext, type TimeoutContext } from './timeout';
 import { filterOptions, getTopology, type MongoDBNamespace, squashError } from './utils';
 
-/** @internal */
-const kCursorStream = Symbol('cursorStream');
-/** @internal */
-const kClosed = Symbol('closed');
-/** @internal */
-const kMode = Symbol('mode');
-
 const CHANGE_STREAM_OPTIONS = [
   'resumeAfter',
   'startAfter',
@@ -584,14 +577,14 @@ export class ChangeStream<
   namespace: MongoDBNamespace;
   type: symbol;
   /** @internal */
-  cursor: ChangeStreamCursor<TSchema, TChange>;
+  private cursor: ChangeStreamCursor<TSchema, TChange>;
   streamOptions?: CursorStreamOptions;
   /** @internal */
-  [kCursorStream]?: Readable & AsyncIterable<TChange>;
+  private cursorStream?: Readable & AsyncIterable<TChange>;
   /** @internal */
-  [kClosed]: boolean;
+  private isClosed: boolean;
   /** @internal */
-  [kMode]: false | 'iterator' | 'emitter';
+  private mode: false | 'iterator' | 'emitter';
 
   /** @event */
   static readonly RESPONSE = RESPONSE;
@@ -668,8 +661,8 @@ export class ChangeStream<
     // Create contained Change Stream cursor
     this.cursor = this._createChangeStreamCursor(options);
 
-    this[kClosed] = false;
-    this[kMode] = false;
+    this.isClosed = false;
+    this.mode = false;
 
     // Listen for any `change` listeners being added to ChangeStream
     this.on('newListener', eventName => {
@@ -680,7 +673,7 @@ export class ChangeStream<
 
     this.on('removeListener', eventName => {
       if (eventName === 'change' && this.listenerCount('change') === 0 && this.cursor) {
-        this[kCursorStream]?.removeAllListeners('data');
+        this.cursorStream?.removeAllListeners('data');
       }
     });
 
@@ -692,11 +685,6 @@ export class ChangeStream<
     }
   }
 
-  /** @internal */
-  get cursorStream(): (Readable & AsyncIterable<TChange>) | undefined {
-    return this[kCursorStream];
-  }
-
   /** The cached resume token that is used to resume after the most recently returned change. */
   get resumeToken(): ResumeToken {
     return this.cursor?.resumeToken;
@@ -826,8 +814,8 @@ export class ChangeStream<
   }
 
   /** Is the cursor closed */
-  get closed(): boolean {
-    return this[kClosed] || this.cursor.closed;
+  public get closed(): boolean {
+    return this.isClosed || this.cursor.closed;
   }
 
   /**
@@ -836,7 +824,7 @@ export class ChangeStream<
   async close(): Promise<void> {
     this.timeoutContext?.clear();
     this.timeoutContext = undefined;
-    this[kClosed] = true;
+    this.isClosed = true;
 
     const cursor = this.cursor;
     try {
@@ -865,24 +853,24 @@ export class ChangeStream<
 
   /** @internal */
   private _setIsEmitter(): void {
-    if (this[kMode] === 'iterator') {
+    if (this.mode === 'iterator') {
       // TODO(NODE-3485): Replace with MongoChangeStreamModeError
       throw new MongoAPIError(
         'ChangeStream cannot be used as an EventEmitter after being used as an iterator'
       );
     }
-    this[kMode] = 'emitter';
+    this.mode = 'emitter';
   }
 
   /** @internal */
   private _setIsIterator(): void {
-    if (this[kMode] === 'emitter') {
+    if (this.mode === 'emitter') {
       // TODO(NODE-3485): Replace with MongoChangeStreamModeError
       throw new MongoAPIError(
         'ChangeStream cannot be used as an iterator after being used as an EventEmitter'
       );
     }
-    this[kMode] = 'iterator';
+    this.mode = 'iterator';
   }
 
   /**
@@ -947,8 +935,8 @@ export class ChangeStream<
   /** @internal */
   private _streamEvents(cursor: ChangeStreamCursor<TSchema, TChange>): void {
     this._setIsEmitter();
-    const stream = this[kCursorStream] ?? cursor.stream();
-    this[kCursorStream] = stream;
+    const stream = this.cursorStream ?? cursor.stream();
+    this.cursorStream = stream;
     stream.on('data', change => {
       try {
         const processedChange = this._processChange(change);
@@ -963,18 +951,18 @@ export class ChangeStream<
 
   /** @internal */
   private _endStream(): void {
-    const cursorStream = this[kCursorStream];
+    const cursorStream = this.cursorStream;
     if (cursorStream) {
       ['data', 'close', 'end', 'error'].forEach(event => cursorStream.removeAllListeners(event));
       cursorStream.destroy();
     }
 
-    this[kCursorStream] = undefined;
+    this.cursorStream = undefined;
   }
 
   /** @internal */
   private _processChange(change: TChange | null): TChange {
-    if (this[kClosed]) {
+    if (this.isClosed) {
       // TODO(NODE-3485): Replace with MongoChangeStreamClosedError
       throw new MongoAPIError(CHANGESTREAM_CLOSED_ERROR);
     }
@@ -1002,7 +990,7 @@ export class ChangeStream<
   /** @internal */
   private _processErrorStreamMode(changeStreamError: AnyError, cursorInitialized: boolean) {
     // If the change stream has been closed explicitly, do not process error.
-    if (this[kClosed]) return;
+    if (this.isClosed) return;
 
     if (
       cursorInitialized &&
@@ -1034,7 +1022,7 @@ export class ChangeStream<
 
   /** @internal */
   private async _processErrorIteratorMode(changeStreamError: AnyError, cursorInitialized: boolean) {
-    if (this[kClosed]) {
+    if (this.isClosed) {
       // TODO(NODE-3485): Replace with MongoChangeStreamClosedError
       throw new MongoAPIError(CHANGESTREAM_CLOSED_ERROR);
     }

package/src/cmap/connect.ts

@@ -386,15 +386,35 @@ export async function makeSocket(options: MakeConnectionOptions): Promise<Stream
   if (existingSocket) {
     resolve(socket);
   } else {
+    const start = performance.now();
     const connectEvent = useTLS ? 'secureConnect' : 'connect';
     socket
       .once(connectEvent, () => resolve(socket))
-      .once('error', error => reject(connectionFailureError('error', error)))
-      .once('timeout', () => reject(connectionFailureError('timeout')))
-      .once('close', () => reject(connectionFailureError('close')));
+      .once('error', cause =>
+        reject(new MongoNetworkError(MongoError.buildErrorMessage(cause), { cause }))
+      )
+      .once('timeout', () => {
+        reject(
+          new MongoNetworkTimeoutError(
+            `Socket '${connectEvent}' timed out after ${(performance.now() - start) | 0}ms (connectTimeoutMS: ${connectTimeoutMS})`
+          )
+        );
+      })
+      .once('close', () =>
+        reject(
+          new MongoNetworkError(
+            `Socket closed after ${(performance.now() - start) | 0} during connection establishment`
+          )
+        )
+      );
 
     if (options.cancellationToken != null) {
-      cancellationHandler = () => reject(connectionFailureError('cancel'));
+      cancellationHandler = () =>
+        reject(
+          new MongoNetworkError(
+            `Socket connection establishment was cancelled after ${(performance.now() - start) | 0}`
+          )
+        );
       options.cancellationToken.once('cancel', cancellationHandler);
     }
   }
@@ -447,9 +467,11 @@ async function makeSocks5Connection(options: MakeConnectionOptions): Promise<Str
 
   socks ??= loadSocks();
 
+  let existingSocket: Stream;
+
   try {
     // Then, establish the Socks5 proxy connection:
-    const { socket } = await socks.SocksClient.createConnection({
+    const connection = await socks.SocksClient.createConnection({
       existing_socket: rawSocket,
       timeout: options.connectTimeoutMS,
       command: 'connect',
@@ -466,35 +488,12 @@ async function makeSocks5Connection(options: MakeConnectionOptions): Promise<Str
         password: options.proxyPassword || undefined
       }
     });
-
-    // Finally, now treat the resulting duplex stream as the
-    // socket over which we send and receive wire protocol messages:
-    return await makeSocket({
-      ...options,
-      existingSocket: socket,
-      proxyHost: undefined
-    });
-  } catch (error) {
-    throw connectionFailureError('error', error);
+    existingSocket = connection.socket;
+  } catch (cause) {
+    throw new MongoNetworkError(MongoError.buildErrorMessage(cause), { cause });
   }
-}
 
-function connectionFailureError(type: 'error', cause: Error): MongoNetworkError;
-function connectionFailureError(type: 'close' | 'timeout' | 'cancel'): MongoNetworkError;
-function connectionFailureError(
-  type: 'error' | 'close' | 'timeout' | 'cancel',
-  cause?: Error
-): MongoNetworkError {
-  switch (type) {
-    case 'error':
-      return new MongoNetworkError(MongoError.buildErrorMessage(cause), { cause });
-    case 'timeout':
-      return new MongoNetworkTimeoutError('connection timed out');
-    case 'close':
-      return new MongoNetworkError('connection closed');
-    case 'cancel':
-      return new MongoNetworkError('connection establishment was cancelled');
-    default:
-      return new MongoNetworkError('unknown network error');
-  }
+  // Finally, now treat the resulting duplex stream as the
+  // socket over which we send and receive wire protocol messages:
+  return await makeSocket({ ...options, existingSocket, proxyHost: undefined });
 }

package/src/cmap/connection.ts

@@ -769,7 +769,7 @@ export class SizedMessageTransform extends Transform {
   connection: Connection;
 
   constructor({ connection }: { connection: Connection }) {
-    super({ objectMode: false });
+    super({ writableObjectMode: false, readableObjectMode: true });
     this.bufferPool = new BufferPool();
     this.connection = connection;
   }