mongodb 6.12.0-dev.20241211.sha.2f9ad4d4 → 6.12.0-dev.20241212.sha.f6d7868f

package/src/error.ts

@@ -10,9 +10,6 @@ import type { TopologyDescription } from './sdam/topology_description';
 /** @public */
 export type AnyError = MongoError | Error;
 
-/** @internal */
-const kErrorLabels = Symbol('errorLabels');
-
 /**
  * @internal
  * The legacy error message from the server that indicates the node is not a writable primary
@@ -129,7 +126,11 @@ function isAggregateError(e: unknown): e is Error & { errors: Error[] } {
  */
 export class MongoError extends Error {
   /** @internal */
-  [kErrorLabels]: Set<string>;
+  private readonly errorLabelSet: Set<string> = new Set();
+  public get errorLabels(): string[] {
+    return Array.from(this.errorLabelSet);
+  }
+
   /**
    * This is a number in MongoServerError and a string in MongoDriverError
    * @privateRemarks
@@ -153,7 +154,6 @@ export class MongoError extends Error {
    **/
   constructor(message: string, options?: { cause?: Error }) {
     super(message, options);
-    this[kErrorLabels] = new Set();
   }
 
   /** @internal */
@@ -188,15 +188,11 @@ export class MongoError extends Error {
    * @returns returns true if the error has the provided error label
    */
   hasErrorLabel(label: string): boolean {
-    return this[kErrorLabels].has(label);
+    return this.errorLabelSet.has(label);
   }
 
   addErrorLabel(label: string): void {
-    this[kErrorLabels].add(label);
-  }
-
-  get errorLabels(): string[] {
-    return Array.from(this[kErrorLabels]);
+    this.errorLabelSet.add(label);
   }
 }
 
@@ -228,8 +224,9 @@ export class MongoServerError extends MongoError {
    **/
   constructor(message: ErrorDescription) {
     super(message.message || message.errmsg || message.$err || 'n/a');
+
     if (message.errorLabels) {
-      this[kErrorLabels] = new Set(message.errorLabels);
+      for (const label of message.errorLabels) this.addErrorLabel(label);
     }
 
     this.errorResponse = message;
@@ -1028,12 +1025,6 @@ export class MongoTopologyClosedError extends MongoAPIError {
   }
 }
 
-/** @internal */
-const kBeforeHandshake = Symbol('beforeHandshake');
-export function isNetworkErrorBeforeHandshake(err: MongoNetworkError): boolean {
-  return err[kBeforeHandshake] === true;
-}
-
 /** @public */
 export interface MongoNetworkErrorOptions {
   /** Indicates the timeout happened before a connection handshake completed */
@@ -1048,7 +1039,7 @@ export interface MongoNetworkErrorOptions {
  */
 export class MongoNetworkError extends MongoError {
   /** @internal */
-  [kBeforeHandshake]?: boolean;
+  public readonly beforeHandshake: boolean;
 
   /**
    * **Do not use this constructor!**
@@ -1063,10 +1054,7 @@ export class MongoNetworkError extends MongoError {
    **/
   constructor(message: string, options?: MongoNetworkErrorOptions) {
     super(message, { cause: options?.cause });
-
-    if (options && typeof options.beforeHandshake === 'boolean') {
-      this[kBeforeHandshake] = options.beforeHandshake;
-    }
+    this.beforeHandshake = !!options?.beforeHandshake;
   }
 
   override get name(): string {

package/src/mongo_client.ts

@@ -333,9 +333,6 @@ export type MongoClientEvents = Pick<TopologyEvents, (typeof MONGO_CLIENT_EVENTS
   open(mongoClient: MongoClient): void;
 };
 
-/** @internal */
-const kOptions = Symbol('options');
-
 /**
  * The **MongoClient** class is a class that allows for making Connections to MongoDB.
  * @public
@@ -367,20 +364,22 @@ export class MongoClient extends TypedEventEmitter<MongoClientEvents> implements
 
   /**
    * The consolidate, parsed, transformed and merged options.
-   * @internal
    */
-  [kOptions]: MongoOptions;
+  public readonly options: Readonly<
+    Omit<MongoOptions, 'monitorCommands' | 'ca' | 'crl' | 'key' | 'cert'>
+  > &
+    Pick<MongoOptions, 'monitorCommands' | 'ca' | 'crl' | 'key' | 'cert'>;
 
   constructor(url: string, options?: MongoClientOptions) {
     super();
 
-    this[kOptions] = parseOptions(url, this, options);
+    this.options = parseOptions(url, this, options);
 
-    const shouldSetLogger = Object.values(
-      this[kOptions].mongoLoggerOptions.componentSeverities
-    ).some(value => value !== SeverityLevel.OFF);
+    const shouldSetLogger = Object.values(this.options.mongoLoggerOptions.componentSeverities).some(
+      value => value !== SeverityLevel.OFF
+    );
     this.mongoLogger = shouldSetLogger
-      ? new MongoLogger(this[kOptions].mongoLoggerOptions)
+      ? new MongoLogger(this.options.mongoLoggerOptions)
       : undefined;
 
     // eslint-disable-next-line @typescript-eslint/no-this-alias
@@ -389,7 +388,7 @@ export class MongoClient extends TypedEventEmitter<MongoClientEvents> implements
     // The internal state
     this.s = {
       url,
-      bsonOptions: resolveBSONOptions(this[kOptions]),
+      bsonOptions: resolveBSONOptions(this.options),
       namespace: ns('admin'),
       hasBeenClosed: false,
       sessionPool: new ServerSessionPool(this),
@@ -397,16 +396,16 @@ export class MongoClient extends TypedEventEmitter<MongoClientEvents> implements
       authProviders: new MongoClientAuthProviders(),
 
       get options() {
-        return client[kOptions];
+        return client.options;
       },
       get readConcern() {
-        return client[kOptions].readConcern;
+        return client.options.readConcern;
       },
       get writeConcern() {
-        return client[kOptions].writeConcern;
+        return client.options.writeConcern;
       },
       get readPreference() {
-        return client[kOptions].readPreference;
+        return client.options.readPreference;
       },
       get isMongoClient(): true {
         return true;
@@ -428,15 +427,15 @@ export class MongoClient extends TypedEventEmitter<MongoClientEvents> implements
 
   /** @internal */
   private checkForNonGenuineHosts() {
-    const documentDBHostnames = this[kOptions].hosts.filter((hostAddress: HostAddress) =>
+    const documentDBHostnames = this.options.hosts.filter((hostAddress: HostAddress) =>
       isHostMatch(DOCUMENT_DB_CHECK, hostAddress.host)
     );
-    const srvHostIsDocumentDB = isHostMatch(DOCUMENT_DB_CHECK, this[kOptions].srvHost);
+    const srvHostIsDocumentDB = isHostMatch(DOCUMENT_DB_CHECK, this.options.srvHost);
 
-    const cosmosDBHostnames = this[kOptions].hosts.filter((hostAddress: HostAddress) =>
+    const cosmosDBHostnames = this.options.hosts.filter((hostAddress: HostAddress) =>
       isHostMatch(COSMOS_DB_CHECK, hostAddress.host)
     );
-    const srvHostIsCosmosDB = isHostMatch(COSMOS_DB_CHECK, this[kOptions].srvHost);
+    const srvHostIsCosmosDB = isHostMatch(COSMOS_DB_CHECK, this.options.srvHost);
 
     if (documentDBHostnames.length !== 0 || srvHostIsDocumentDB) {
       this.mongoLogger?.info('client', DOCUMENT_DB_MSG);
@@ -445,28 +444,23 @@ export class MongoClient extends TypedEventEmitter<MongoClientEvents> implements
     }
   }
 
-  /** @see MongoOptions */
-  get options(): Readonly<MongoOptions> {
-    return Object.freeze({ ...this[kOptions] });
-  }
-
   get serverApi(): Readonly<ServerApi | undefined> {
-    return this[kOptions].serverApi && Object.freeze({ ...this[kOptions].serverApi });
+    return this.options.serverApi && Object.freeze({ ...this.options.serverApi });
   }
   /**
    * Intended for APM use only
    * @internal
    */
   get monitorCommands(): boolean {
-    return this[kOptions].monitorCommands;
+    return this.options.monitorCommands;
   }
   set monitorCommands(value: boolean) {
-    this[kOptions].monitorCommands = value;
+    this.options.monitorCommands = value;
   }
 
   /** @internal */
   get autoEncrypter(): AutoEncrypter | undefined {
-    return this[kOptions].autoEncrypter;
+    return this.options.autoEncrypter;
   }
 
   get readConcern(): ReadConcern | undefined {
@@ -551,7 +545,7 @@ export class MongoClient extends TypedEventEmitter<MongoClientEvents> implements
       return this;
     }
 
-    const options = this[kOptions];
+    const options = this.options;
 
     if (options.tls) {
       if (typeof options.tlsCAFile === 'string') {
@@ -685,7 +679,7 @@ export class MongoClient extends TypedEventEmitter<MongoClientEvents> implements
 
     topology.close();
 
-    const { encrypter } = this[kOptions];
+    const { encrypter } = this.options;
     if (encrypter) {
       await encrypter.close(this, force);
     }
@@ -706,7 +700,7 @@ export class MongoClient extends TypedEventEmitter<MongoClientEvents> implements
     }
 
     // Copy the options and add out internal override of the not shared flag
-    const finalOptions = Object.assign({}, this[kOptions], options);
+    const finalOptions = Object.assign({}, this.options, options);
 
     // Return the db object
     const db = new Db(this, dbName, finalOptions);
@@ -748,7 +742,7 @@ export class MongoClient extends TypedEventEmitter<MongoClientEvents> implements
       this,
       this.s.sessionPool,
       { explicit: true, ...options },
-      this[kOptions]
+      this.options
     );
     this.s.activeSessions.add(session);
     session.once('ended', () => {

package/src/operations/operation.ts

@@ -42,9 +42,6 @@ export interface OperationOptions extends BSONSerializeOptions {
   timeoutMS?: number;
 }
 
-/** @internal */
-const kSession = Symbol('session');
-
 /**
  * This class acts as a parent class for any operation and is responsible for setting this.options,
  * as well as setting and getting a session.
@@ -67,7 +64,7 @@ export abstract class AbstractOperation<TResult = any> {
   /** Specifies the time an operation will run until it throws a timeout error. */
   timeoutMS?: number;
 
-  [kSession]: ClientSession | undefined;
+  private _session: ClientSession | undefined;
 
   static aspects?: Set<symbol>;
 
@@ -79,7 +76,7 @@ export abstract class AbstractOperation<TResult = any> {
     // Pull the BSON serialize options from the already-resolved options
     this.bsonOptions = resolveBSONOptions(options);
 
-    this[kSession] = options.session != null ? options.session : undefined;
+    this._session = options.session != null ? options.session : undefined;
 
     this.options = options;
     this.bypassPinningCheck = !!options.bypassPinningCheck;
@@ -105,12 +102,13 @@ export abstract class AbstractOperation<TResult = any> {
     return ctor.aspects.has(aspect);
   }
 
+  // Make sure the session is not writable from outside this class.
   get session(): ClientSession | undefined {
-    return this[kSession];
+    return this._session;
   }
 
   clearSession() {
-    this[kSession] = undefined;
+    this._session = undefined;
   }
 
   resetBatch(): boolean {

package/src/sdam/monitor.ts

@@ -25,13 +25,6 @@ import {
 import { Server } from './server';
 import type { TopologyVersion } from './server_description';
 
-/** @internal */
-const kServer = Symbol('server');
-/** @internal */
-const kMonitorId = Symbol('monitorId');
-/** @internal */
-const kCancellationToken = Symbol('cancellationToken');
-
 const STATE_IDLE = 'idle';
 const STATE_MONITORING = 'monitoring';
 const stateTransition = makeStateMachine({
@@ -96,11 +89,11 @@ export class Monitor extends TypedEventEmitter<MonitorEvents> {
   >;
   connectOptions: ConnectionOptions;
   isRunningInFaasEnv: boolean;
-  [kServer]: Server;
+  server: Server;
   connection: Connection | null;
-  [kCancellationToken]: CancellationToken;
+  cancellationToken: CancellationToken;
   /** @internal */
-  [kMonitorId]?: MonitorInterval;
+  monitorId?: MonitorInterval;
   rttPinger?: RTTPinger;
   /** @internal */
   override component = MongoLoggableComponent.TOPOLOGY;
@@ -110,11 +103,11 @@ export class Monitor extends TypedEventEmitter<MonitorEvents> {
   constructor(server: Server, options: MonitorOptions) {
     super();
 
-    this[kServer] = server;
+    this.server = server;
     this.connection = null;
-    this[kCancellationToken] = new CancellationToken();
-    this[kCancellationToken].setMaxListeners(Infinity);
-    this[kMonitorId] = undefined;
+    this.cancellationToken = new CancellationToken();
+    this.cancellationToken.setMaxListeners(Infinity);
+    this.monitorId = undefined;
     this.s = {
       state: STATE_CLOSED
     };
@@ -126,10 +119,10 @@ export class Monitor extends TypedEventEmitter<MonitorEvents> {
       serverMonitoringMode: options.serverMonitoringMode
     });
     this.isRunningInFaasEnv = getFAASEnv() != null;
-    this.mongoLogger = this[kServer].topology.client?.mongoLogger;
+    this.mongoLogger = this.server.topology.client?.mongoLogger;
     this.rttSampler = new RTTSampler(10);
 
-    const cancellationToken = this[kCancellationToken];
+    const cancellationToken = this.cancellationToken;
     // TODO: refactor this to pull it directly from the pool, requires new ConnectionPool integration
     const connectOptions = {
       id: '<monitor>' as const,
@@ -162,7 +155,7 @@ export class Monitor extends TypedEventEmitter<MonitorEvents> {
     // start
     const heartbeatFrequencyMS = this.options.heartbeatFrequencyMS;
     const minHeartbeatFrequencyMS = this.options.minHeartbeatFrequencyMS;
-    this[kMonitorId] = new MonitorInterval(monitorServer(this), {
+    this.monitorId = new MonitorInterval(monitorServer(this), {
       heartbeatFrequencyMS: heartbeatFrequencyMS,
       minHeartbeatFrequencyMS: minHeartbeatFrequencyMS,
       immediate: true
@@ -174,11 +167,11 @@ export class Monitor extends TypedEventEmitter<MonitorEvents> {
       return;
     }
 
-    this[kMonitorId]?.wake();
+    this.monitorId?.wake();
   }
 
   reset(): void {
-    const topologyVersion = this[kServer].description.topologyVersion;
+    const topologyVersion = this.server.description.topologyVersion;
     if (isInCloseState(this) || topologyVersion == null) {
       return;
     }
@@ -192,7 +185,7 @@ export class Monitor extends TypedEventEmitter<MonitorEvents> {
     // restart monitoring
     const heartbeatFrequencyMS = this.options.heartbeatFrequencyMS;
     const minHeartbeatFrequencyMS = this.options.minHeartbeatFrequencyMS;
-    this[kMonitorId] = new MonitorInterval(monitorServer(this), {
+    this.monitorId = new MonitorInterval(monitorServer(this), {
       heartbeatFrequencyMS: heartbeatFrequencyMS,
       minHeartbeatFrequencyMS: minHeartbeatFrequencyMS
     });
@@ -233,13 +226,13 @@ export class Monitor extends TypedEventEmitter<MonitorEvents> {
 }
 
 function resetMonitorState(monitor: Monitor) {
-  monitor[kMonitorId]?.stop();
-  monitor[kMonitorId] = undefined;
+  monitor.monitorId?.stop();
+  monitor.monitorId = undefined;
 
   monitor.rttPinger?.close();
   monitor.rttPinger = undefined;
 
-  monitor[kCancellationToken].emit('cancel');
+  monitor.cancellationToken.emit('cancel');
 
   monitor.connection?.destroy();
   monitor.connection = null;
@@ -266,11 +259,11 @@ function useStreamingProtocol(monitor: Monitor, topologyVersion: TopologyVersion
 function checkServer(monitor: Monitor, callback: Callback<Document | null>) {
   let start: number;
   let awaited: boolean;
-  const topologyVersion = monitor[kServer].description.topologyVersion;
+  const topologyVersion = monitor.server.description.topologyVersion;
   const isAwaitable = useStreamingProtocol(monitor, topologyVersion);
   monitor.emitAndLogHeartbeat(
     Server.SERVER_HEARTBEAT_STARTED,
-    monitor[kServer].topology.s.id,
+    monitor.server.topology.s.id,
     undefined,
     new ServerHeartbeatStartedEvent(monitor.address, isAwaitable)
   );
@@ -280,7 +273,7 @@ function checkServer(monitor: Monitor, callback: Callback<Document | null>) {
     monitor.connection = null;
     monitor.emitAndLogHeartbeat(
       Server.SERVER_HEARTBEAT_FAILED,
-      monitor[kServer].topology.s.id,
+      monitor.server.topology.s.id,
       undefined,
       new ServerHeartbeatFailedEvent(monitor.address, calculateDurationInMs(start), err, awaited)
     );
@@ -315,7 +308,7 @@ function checkServer(monitor: Monitor, callback: Callback<Document | null>) {
 
     monitor.emitAndLogHeartbeat(
       Server.SERVER_HEARTBEAT_SUCCEEDED,
-      monitor[kServer].topology.s.id,
+      monitor.server.topology.s.id,
       hello.connectionId,
       new ServerHeartbeatSucceededEvent(monitor.address, duration, hello, isAwaitable)
     );
@@ -325,7 +318,7 @@ function checkServer(monitor: Monitor, callback: Callback<Document | null>) {
       // event, otherwise the "check" is complete and return to the main monitor loop
       monitor.emitAndLogHeartbeat(
         Server.SERVER_HEARTBEAT_STARTED,
-        monitor[kServer].topology.s.id,
+        monitor.server.topology.s.id,
         undefined,
         new ServerHeartbeatStartedEvent(monitor.address, true)
       );
@@ -378,7 +371,6 @@ function checkServer(monitor: Monitor, callback: Callback<Document | null>) {
     awaited = false;
     connection
       .command(ns('admin.$cmd'), cmd, options)
-
       .then(onHeartbeatSucceeded, onHeartbeatFailed);
 
     return;
@@ -409,7 +401,7 @@ function checkServer(monitor: Monitor, callback: Callback<Document | null>) {
       monitor.connection = connection;
       monitor.emitAndLogHeartbeat(
         Server.SERVER_HEARTBEAT_SUCCEEDED,
-        monitor[kServer].topology.s.id,
+        monitor.server.topology.s.id,
         connection.hello?.connectionId,
         new ServerHeartbeatSucceededEvent(
           monitor.address,
@@ -447,7 +439,7 @@ function monitorServer(monitor: Monitor) {
     checkServer(monitor, (err, hello) => {
       if (err) {
         // otherwise an error occurred on initial discovery, also bail
-        if (monitor[kServer].description.type === ServerType.Unknown) {
+        if (monitor.server.description.type === ServerType.Unknown) {
           return done();
         }
       }
@@ -456,7 +448,7 @@ function monitorServer(monitor: Monitor) {
       if (useStreamingProtocol(monitor, hello?.topologyVersion)) {
         setTimeout(() => {
           if (!isInCloseState(monitor)) {
-            monitor[kMonitorId]?.wake();
+            monitor.monitorId?.wake();
           }
         }, 0);
       }
@@ -484,9 +476,9 @@ export interface RTTPingerOptions extends ConnectionOptions {
 export class RTTPinger {
   connection?: Connection;
   /** @internal */
-  [kCancellationToken]: CancellationToken;
+  cancellationToken: CancellationToken;
   /** @internal */
-  [kMonitorId]: NodeJS.Timeout;
+  monitorId: NodeJS.Timeout;
   /** @internal */
   monitor: Monitor;
   closed: boolean;
@@ -495,13 +487,13 @@ export class RTTPinger {
 
   constructor(monitor: Monitor) {
     this.connection = undefined;
-    this[kCancellationToken] = monitor[kCancellationToken];
+    this.cancellationToken = monitor.cancellationToken;
     this.closed = false;
     this.monitor = monitor;
     this.latestRtt = monitor.latestRtt ?? undefined;
 
     const heartbeatFrequencyMS = monitor.options.heartbeatFrequencyMS;
-    this[kMonitorId] = setTimeout(() => this.measureRoundTripTime(), heartbeatFrequencyMS);
+    this.monitorId = setTimeout(() => this.measureRoundTripTime(), heartbeatFrequencyMS);
   }
 
   get roundTripTime(): number {
@@ -514,7 +506,7 @@ export class RTTPinger {
 
   close(): void {
     this.closed = true;
-    clearTimeout(this[kMonitorId]);
+    clearTimeout(this.monitorId);
 
     this.connection?.destroy();
     this.connection = undefined;
@@ -531,7 +523,7 @@ export class RTTPinger {
     }
 
     this.latestRtt = calculateDurationInMs(start);
-    this[kMonitorId] = setTimeout(
+    this.monitorId = setTimeout(
       () => this.measureRoundTripTime(),
       this.monitor.options.heartbeatFrequencyMS
     );

package/src/sdam/server.ts

@@ -22,7 +22,6 @@ import {
 } from '../constants';
 import {
   type AnyError,
-  isNetworkErrorBeforeHandshake,
   isNodeShuttingDownError,
   isSDAMUnrecoverableError,
   MONGODB_ERROR_CODES,
@@ -381,7 +380,8 @@ export class Server extends TypedEventEmitter<ServerEvents> {
 
     const isNetworkNonTimeoutError =
       error instanceof MongoNetworkError && !(error instanceof MongoNetworkTimeoutError);
-    const isNetworkTimeoutBeforeHandshakeError = isNetworkErrorBeforeHandshake(error);
+    const isNetworkTimeoutBeforeHandshakeError =
+      error instanceof MongoNetworkError && error.beforeHandshake;
     const isAuthHandshakeError = error.hasErrorLabel(MongoErrorLabel.HandshakeError);
     if (isNetworkNonTimeoutError || isNetworkTimeoutBeforeHandshakeError || isAuthHandshakeError) {
       // In load balanced mode we never mark the server as unknown and always

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() {