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

package/src/sdam/topology.ts

@@ -88,11 +88,6 @@ const stateTransition = makeStateMachine({
   [STATE_CLOSING]: [STATE_CLOSING, STATE_CLOSED]
 });
 
-/** @internal */
-const kCancelled = Symbol('cancelled');
-/** @internal */
-const kWaitQueue = Symbol('waitQueue');
-
 /** @internal */
 export type ServerSelectionCallback = Callback<Server>;
 
@@ -105,7 +100,7 @@ export interface ServerSelectionRequest {
   startTime: number;
   resolve: (server: Server) => void;
   reject: (error: MongoError) => void;
-  [kCancelled]?: boolean;
+  cancelled: boolean;
   operationName: string;
   waitingLogged: boolean;
   previousServer?: ServerDescription;
@@ -208,7 +203,7 @@ export class Topology extends TypedEventEmitter<TopologyEvents> {
   /** @internal */
   s: TopologyPrivate;
   /** @internal */
-  [kWaitQueue]: List<ServerSelectionRequest>;
+  waitQueue: List<ServerSelectionRequest>;
   /** @internal */
   hello?: Document;
   /** @internal */
@@ -293,7 +288,7 @@ export class Topology extends TypedEventEmitter<TopologyEvents> {
       serverDescriptions.set(hostAddress.toString(), new ServerDescription(hostAddress));
     }
 
-    this[kWaitQueue] = new List();
+    this.waitQueue = new List();
     this.s = {
       // the id of this topology
       id: topologyId,
@@ -506,7 +501,7 @@ export class Topology extends TypedEventEmitter<TopologyEvents> {
 
     stateTransition(this, STATE_CLOSING);
 
-    drainWaitQueue(this[kWaitQueue], new MongoTopologyClosedError());
+    drainWaitQueue(this.waitQueue, new MongoTopologyClosedError());
 
     if (this.s.srvPoller) {
       this.s.srvPoller.stop();
@@ -601,13 +596,14 @@ export class Topology extends TypedEventEmitter<TopologyEvents> {
       transaction,
       resolve,
       reject,
+      cancelled: false,
       startTime: now(),
       operationName: options.operationName,
       waitingLogged: false,
       previousServer: options.previousServer
     };
 
-    this[kWaitQueue].push(waitQueueMember);
+    this.waitQueue.push(waitQueueMember);
     processWaitQueue(this);
 
     try {
@@ -620,7 +616,7 @@ export class Topology extends TypedEventEmitter<TopologyEvents> {
     } catch (error) {
       if (TimeoutError.is(error)) {
         // Timeout
-        waitQueueMember[kCancelled] = true;
+        waitQueueMember.cancelled = true;
         const timeoutError = new MongoServerSelectionError(
           `Server selection timed out after ${timeout?.duration} ms`,
           this.description
@@ -721,7 +717,7 @@ export class Topology extends TypedEventEmitter<TopologyEvents> {
     updateServers(this, serverDescription);
 
     // attempt to resolve any outstanding server selection attempts
-    if (this[kWaitQueue].length > 0) {
+    if (this.waitQueue.length > 0) {
       processWaitQueue(this);
     }
 
@@ -910,7 +906,7 @@ function drainWaitQueue(queue: List<ServerSelectionRequest>, drainError: MongoDr
       continue;
     }
 
-    if (!waitQueueMember[kCancelled]) {
+    if (!waitQueueMember.cancelled) {
       if (
         waitQueueMember.mongoLogger?.willLog(
           MongoLoggableComponent.SERVER_SELECTION,
@@ -934,20 +930,20 @@ function drainWaitQueue(queue: List<ServerSelectionRequest>, drainError: MongoDr
 
 function processWaitQueue(topology: Topology) {
   if (topology.s.state === STATE_CLOSED) {
-    drainWaitQueue(topology[kWaitQueue], new MongoTopologyClosedError());
+    drainWaitQueue(topology.waitQueue, new MongoTopologyClosedError());
     return;
   }
 
   const isSharded = topology.description.type === TopologyType.Sharded;
   const serverDescriptions = Array.from(topology.description.servers.values());
-  const membersToProcess = topology[kWaitQueue].length;
+  const membersToProcess = topology.waitQueue.length;
   for (let i = 0; i < membersToProcess; ++i) {
-    const waitQueueMember = topology[kWaitQueue].shift();
+    const waitQueueMember = topology.waitQueue.shift();
     if (!waitQueueMember) {
       continue;
     }
 
-    if (waitQueueMember[kCancelled]) {
+    if (waitQueueMember.cancelled) {
       continue;
     }
 
@@ -1006,7 +1002,7 @@ function processWaitQueue(topology: Topology) {
         }
         waitQueueMember.waitingLogged = true;
       }
-      topology[kWaitQueue].push(waitQueueMember);
+      topology.waitQueue.push(waitQueueMember);
       continue;
     } else if (selectedDescriptions.length === 1) {
       selectedServer = topology.s.servers.get(selectedDescriptions[0].address);
@@ -1069,7 +1065,7 @@ function processWaitQueue(topology: Topology) {
     waitQueueMember.resolve(selectedServer);
   }
 
-  if (topology[kWaitQueue].length > 0) {
+  if (topology.waitQueue.length > 0) {
     // ensure all server monitors attempt monitoring soon
     for (const [, server] of topology.s.servers) {
       process.nextTick(function scheduleServerCheck() {

package/src/sdam/topology_description.ts

@@ -1,6 +1,6 @@
 import { EJSON, type ObjectId } from '../bson';
 import * as WIRE_CONSTANTS from '../cmap/wire_protocol/constants';
-import { type MongoError, MongoRuntimeError } from '../error';
+import { type MongoError, MongoRuntimeError, MongoStalePrimaryError } from '../error';
 import { compareObjectId, shuffle } from '../utils';
 import { ServerType, TopologyType } from './common';
 import { ServerDescription } from './server_description';
@@ -400,7 +400,9 @@ function updateRsFromPrimary(
       // replace serverDescription with a default ServerDescription of type "Unknown"
       serverDescriptions.set(
         serverDescription.address,
-        new ServerDescription(serverDescription.address)
+        new ServerDescription(serverDescription.address, undefined, {
+          error: new MongoStalePrimaryError(serverDescription, maxSetVersion, maxElectionId)
+        })
       );
 
       return [checkHasPrimary(serverDescriptions), setName, maxSetVersion, maxElectionId];
@@ -416,7 +418,9 @@ function updateRsFromPrimary(
           // this primary is stale, we must remove it
           serverDescriptions.set(
             serverDescription.address,
-            new ServerDescription(serverDescription.address)
+            new ServerDescription(serverDescription.address, undefined, {
+              error: new MongoStalePrimaryError(serverDescription, maxSetVersion, maxElectionId)
+            })
           );
 
           return [checkHasPrimary(serverDescriptions), setName, maxSetVersion, maxElectionId];
@@ -438,7 +442,12 @@ function updateRsFromPrimary(
   for (const [address, server] of serverDescriptions) {
     if (server.type === ServerType.RSPrimary && server.address !== serverDescription.address) {
       // Reset old primary's type to Unknown.
-      serverDescriptions.set(address, new ServerDescription(server.address));
+      serverDescriptions.set(
+        address,
+        new ServerDescription(server.address, undefined, {
+          error: new MongoStalePrimaryError(serverDescription, maxSetVersion, maxElectionId)
+        })
+      );
 
       // There can only be one primary
       break;

package/src/sessions.ts

@@ -83,17 +83,6 @@ export type ClientSessionEvents = {
   ended(session: ClientSession): void;
 };
 
-/** @internal */
-const kServerSession = Symbol('serverSession');
-/** @internal */
-const kSnapshotTime = Symbol('snapshotTime');
-/** @internal */
-const kSnapshotEnabled = Symbol('snapshotEnabled');
-/** @internal */
-const kPinnedConnection = Symbol('pinnedConnection');
-/** @internal Accumulates total number of increments to add to txnNumber when applying session to command */
-const kTxnNumberIncrement = Symbol('txnNumberIncrement');
-
 /** @public */
 export interface EndSessionOptions {
   /**
@@ -132,20 +121,22 @@ export class ClientSession
   owner?: symbol | AbstractCursor;
   defaultTransactionOptions: TransactionOptions;
   transaction: Transaction;
-  /** @internal
+  /**
+   * @internal
    * Keeps track of whether or not the current transaction has attempted to be committed. Is
-   * initially undefined. Gets set to false when startTransaction is called. When commitTransaction is sent to server, if the commitTransaction succeeds, it is then set to undefined, otherwise, set to true */
-  commitAttempted?: boolean;
-  /** @internal */
-  private [kServerSession]: ServerSession | null;
+   * initially undefined. Gets set to false when startTransaction is called. When commitTransaction is sent to server, if the commitTransaction succeeds, it is then set to undefined, otherwise, set to true
+   */
+  private commitAttempted?: boolean;
+  public readonly snapshotEnabled: boolean;
+
   /** @internal */
-  [kSnapshotTime]?: Timestamp;
+  private _serverSession: ServerSession | null;
   /** @internal */
-  [kSnapshotEnabled] = false;
+  public snapshotTime?: Timestamp;
   /** @internal */
-  [kPinnedConnection]?: Connection;
+  public pinnedConnection?: Connection;
   /** @internal */
-  [kTxnNumberIncrement]: number;
+  public txnNumberIncrement: number;
   /**
    * @experimental
    * Specifies the time an operation in a given `ClientSession` will run until it throws a timeout error
@@ -183,13 +174,11 @@ export class ClientSession
 
     options = options ?? {};
 
-    if (options.snapshot === true) {
-      this[kSnapshotEnabled] = true;
-      if (options.causalConsistency === true) {
-        throw new MongoInvalidArgumentError(
-          'Properties "causalConsistency" and "snapshot" are mutually exclusive'
-        );
-      }
+    this.snapshotEnabled = options.snapshot === true;
+    if (options.causalConsistency === true && this.snapshotEnabled) {
+      throw new MongoInvalidArgumentError(
+        'Properties "causalConsistency" and "snapshot" are mutually exclusive'
+      );
     }
 
     this.client = client;
@@ -199,8 +188,8 @@ export class ClientSession
     this.timeoutMS = options.defaultTimeoutMS ?? client.s.options?.timeoutMS;
 
     this.explicit = !!options.explicit;
-    this[kServerSession] = this.explicit ? this.sessionPool.acquire() : null;
-    this[kTxnNumberIncrement] = 0;
+    this._serverSession = this.explicit ? this.sessionPool.acquire() : null;
+    this.txnNumberIncrement = 0;
 
     const defaultCausalConsistencyValue = this.explicit && options.snapshot !== true;
     this.supports = {
@@ -218,11 +207,11 @@ export class ClientSession
 
   /** The server id associated with this session */
   get id(): ServerSessionId | undefined {
-    return this[kServerSession]?.id;
+    return this.serverSession?.id;
   }
 
   get serverSession(): ServerSession {
-    let serverSession = this[kServerSession];
+    let serverSession = this._serverSession;
     if (serverSession == null) {
       if (this.explicit) {
         throw new MongoRuntimeError('Unexpected null serverSession for an explicit session');
@@ -231,32 +220,22 @@ export class ClientSession
         throw new MongoRuntimeError('Unexpected null serverSession for an ended implicit session');
       }
       serverSession = this.sessionPool.acquire();
-      this[kServerSession] = serverSession;
+      this._serverSession = serverSession;
     }
     return serverSession;
   }
 
-  /** Whether or not this session is configured for snapshot reads */
-  get snapshotEnabled(): boolean {
-    return this[kSnapshotEnabled];
-  }
-
   get loadBalanced(): boolean {
     return this.client.topology?.description.type === TopologyType.LoadBalanced;
   }
 
-  /** @internal */
-  get pinnedConnection(): Connection | undefined {
-    return this[kPinnedConnection];
-  }
-
   /** @internal */
   pin(conn: Connection): void {
-    if (this[kPinnedConnection]) {
+    if (this.pinnedConnection) {
       throw TypeError('Cannot pin multiple connections to the same session');
     }
 
-    this[kPinnedConnection] = conn;
+    this.pinnedConnection = conn;
     conn.emit(
       PINNED,
       this.inTransaction() ? ConnectionPoolMetrics.TXN : ConnectionPoolMetrics.CURSOR
@@ -273,7 +252,7 @@ export class ClientSession
   }
 
   get isPinned(): boolean {
-    return this.loadBalanced ? !!this[kPinnedConnection] : this.transaction.isPinned;
+    return this.loadBalanced ? !!this.pinnedConnection : this.transaction.isPinned;
   }
 
   /**
@@ -295,12 +274,12 @@ export class ClientSession
       squashError(error);
     } finally {
       if (!this.hasEnded) {
-        const serverSession = this[kServerSession];
+        const serverSession = this.serverSession;
         if (serverSession != null) {
           // release the server session back to the pool
           this.sessionPool.release(serverSession);
           // Store a clone of the server session for reference (debugging)
-          this[kServerSession] = new ServerSession(serverSession);
+          this._serverSession = new ServerSession(serverSession);
         }
         // mark the session as ended, and emit a signal
         this.hasEnded = true;
@@ -391,7 +370,7 @@ export class ClientSession
    * This is because the serverSession is lazily acquired after a connection is obtained
    */
   incrementTransactionNumber(): void {
-    this[kTxnNumberIncrement] += 1;
+    this.txnNumberIncrement += 1;
   }
 
   /** @returns whether this session is currently in a transaction or not */
@@ -410,7 +389,7 @@ export class ClientSession
    * @param options - Options for the transaction
    */
   startTransaction(options?: TransactionOptions): void {
-    if (this[kSnapshotEnabled]) {
+    if (this.snapshotEnabled) {
       throw new MongoCompatibilityError('Transactions are not supported in snapshot sessions');
     }
 
@@ -908,7 +887,7 @@ export function maybeClearPinnedConnection(
   options?: EndSessionOptions
 ): void {
   // unpin a connection if it has been pinned
-  const conn = session[kPinnedConnection];
+  const conn = session.pinnedConnection;
   const error = options?.error;
 
   if (
@@ -929,7 +908,7 @@ export function maybeClearPinnedConnection(
 
     if (options?.error == null || options?.force) {
       loadBalancer.pool.checkIn(conn);
-      session[kPinnedConnection] = undefined;
+      session.pinnedConnection = undefined;
       conn.emit(
         UNPINNED,
         session.transaction.state !== TxnState.NO_TRANSACTION
@@ -1123,8 +1102,8 @@ export function applySession(
   const isRetryableWrite = !!options.willRetryWrite;
 
   if (isRetryableWrite || inTxnOrTxnCommand) {
-    serverSession.txnNumber += session[kTxnNumberIncrement];
-    session[kTxnNumberIncrement] = 0;
+    serverSession.txnNumber += session.txnNumberIncrement;
+    session.txnNumberIncrement = 0;
     // TODO(NODE-2674): Preserve int64 sent from MongoDB
     command.txnNumber = Long.fromNumber(serverSession.txnNumber);
   }
@@ -1141,10 +1120,10 @@ export function applySession(
     ) {
       command.readConcern = command.readConcern || {};
       Object.assign(command.readConcern, { afterClusterTime: session.operationTime });
-    } else if (session[kSnapshotEnabled]) {
+    } else if (session.snapshotEnabled) {
       command.readConcern = command.readConcern || { level: ReadConcernLevel.snapshot };
-      if (session[kSnapshotTime] != null) {
-        Object.assign(command.readConcern, { atClusterTime: session[kSnapshotTime] });
+      if (session.snapshotTime != null) {
+        Object.assign(command.readConcern, { atClusterTime: session.snapshotTime });
       }
     }
 
@@ -1187,12 +1166,12 @@ export function updateSessionFromResponse(session: ClientSession, document: Mong
     session.transaction._recoveryToken = document.recoveryToken;
   }
 
-  if (session?.[kSnapshotEnabled] && session[kSnapshotTime] == null) {
+  if (session?.snapshotEnabled && session.snapshotTime == null) {
     // find and aggregate commands return atClusterTime on the cursor
     // distinct includes it in the response body
     const atClusterTime = document.atClusterTime;
     if (atClusterTime) {
-      session[kSnapshotTime] = atClusterTime;
+      session.snapshotTime = atClusterTime;
     }
   }
 }