mongodb 6.18.0-dev.20250802.sha.be7f808c → 6.18.0-dev.20250806.sha.e628296a

package/src/operations/kill_cursors.ts

@@ -1,10 +1,12 @@
 import type { Long } from '../bson';
-import { MongoRuntimeError } from '../error';
-import type { Server } from '../sdam/server';
+import { type Connection } from '../cmap/connection';
+import { MongoDBResponse } from '../cmap/wire_protocol/responses';
+import { type MongoError, MongoRuntimeError } from '../error';
+import type { Server, ServerCommandOptions } from '../sdam/server';
 import type { ClientSession } from '../sessions';
 import { type TimeoutContext } from '../timeout';
-import { type MongoDBNamespace, squashError } from '../utils';
-import { AbstractOperation, Aspect, defineAspects, type OperationOptions } from './operation';
+import { type MongoDBNamespace } from '../utils';
+import { Aspect, defineAspects, ModernizedOperation, type OperationOptions } from './operation';
 
 /**
  * https://www.mongodb.com/docs/manual/reference/command/killCursors/
@@ -16,7 +18,8 @@ interface KillCursorsCommand {
   comment?: unknown;
 }
 
-export class KillCursorsOperation extends AbstractOperation {
+export class KillCursorsOperation extends ModernizedOperation<void> {
+  override SERVER_COMMAND_RESPONSE_TYPE = MongoDBResponse;
   cursorId: Long;
 
   constructor(cursorId: Long, ns: MongoDBNamespace, server: Server, options: OperationOptions) {
@@ -30,15 +33,7 @@ export class KillCursorsOperation extends AbstractOperation {
     return 'killCursors' as const;
   }
 
-  override async execute(
-    server: Server,
-    session: ClientSession | undefined,
-    timeoutContext: TimeoutContext
-  ): Promise<void> {
-    if (server !== this.server) {
-      throw new MongoRuntimeError('Killcursor must run on the same server operation began on');
-    }
-
+  override buildCommand(_connection: Connection, _session?: ClientSession): KillCursorsCommand {
     const killCursors = this.ns.collection;
     if (killCursors == null) {
       // Cursors should have adopted the namespace returned by MongoDB
@@ -50,15 +45,19 @@ export class KillCursorsOperation extends AbstractOperation {
       killCursors,
       cursors: [this.cursorId]
     };
-    try {
-      await server.command(this.ns, killCursorsCommand, {
-        session,
-        timeoutContext
-      });
-    } catch (error) {
-      // The driver should never emit errors from killCursors, this is spec-ed behavior
-      squashError(error);
-    }
+
+    return killCursorsCommand;
+  }
+
+  override buildOptions(timeoutContext: TimeoutContext): ServerCommandOptions {
+    return {
+      session: this.session,
+      timeoutContext
+    };
+  }
+
+  override handleError(_error: MongoError): void {
+    // The driver should never emit errors from killCursors, this is spec-ed behavior
   }
 }
 

package/src/operations/list_collections.ts

@@ -1,13 +1,11 @@
+import { type Connection } from '..';
 import type { Binary, Document } from '../bson';
-import { CursorResponse } from '../cmap/wire_protocol/responses';
+import { CursorResponse, ExplainedCursorResponse } from '../cmap/wire_protocol/responses';
 import { type CursorTimeoutContext, type CursorTimeoutMode } from '../cursor/abstract_cursor';
 import type { Db } from '../db';
 import { type Abortable } from '../mongo_types';
-import type { Server } from '../sdam/server';
-import type { ClientSession } from '../sessions';
-import { type TimeoutContext } from '../timeout';
 import { maxWireVersion } from '../utils';
-import { CommandOperation, type CommandOperationOptions } from './command';
+import { type CommandOperationOptions, ModernizedCommandOperation } from './command';
 import { Aspect, defineAspects } from './operation';
 
 /** @public */
@@ -28,7 +26,8 @@ export interface ListCollectionsOptions
 }
 
 /** @internal */
-export class ListCollectionsOperation extends CommandOperation<CursorResponse> {
+export class ListCollectionsOperation extends ModernizedCommandOperation<CursorResponse> {
+  override SERVER_COMMAND_RESPONSE_TYPE = CursorResponse;
   /**
    * @remarks WriteConcern can still be present on the options because
    * we inherit options from the client/db/collection.  The
@@ -56,28 +55,15 @@ export class ListCollectionsOperation extends CommandOperation<CursorResponse> {
     if (typeof this.options.batchSize === 'number') {
       this.batchSize = this.options.batchSize;
     }
+
+    this.SERVER_COMMAND_RESPONSE_TYPE = this.explain ? ExplainedCursorResponse : CursorResponse;
   }
 
   override get commandName() {
     return 'listCollections' as const;
   }
 
-  override async execute(
-    server: Server,
-    session: ClientSession | undefined,
-    timeoutContext: TimeoutContext
-  ): Promise<CursorResponse> {
-    return await super.executeCommand(
-      server,
-      session,
-      this.generateCommand(maxWireVersion(server)),
-      timeoutContext,
-      CursorResponse
-    );
-  }
-
-  /* This is here for the purpose of unit testing the final command that gets sent. */
-  generateCommand(wireVersion: number): Document {
+  override buildCommandDocument(connection: Connection): Document {
     const command: Document = {
       listCollections: 1,
       filter: this.filter,
@@ -88,12 +74,18 @@ export class ListCollectionsOperation extends CommandOperation<CursorResponse> {
 
     // we check for undefined specifically here to allow falsy values
     // eslint-disable-next-line no-restricted-syntax
-    if (wireVersion >= 9 && this.options.comment !== undefined) {
+    if (maxWireVersion(connection) >= 9 && this.options.comment !== undefined) {
       command.comment = this.options.comment;
     }
 
     return command;
   }
+
+  override handleOk(
+    response: InstanceType<typeof this.SERVER_COMMAND_RESPONSE_TYPE>
+  ): CursorResponse {
+    return response;
+  }
 }
 
 /** @public */

package/src/operations/operation.ts

@@ -1,7 +1,9 @@
+import { type Connection, type MongoError } from '..';
 import { type BSONSerializeOptions, type Document, resolveBSONOptions } from '../bson';
+import { type MongoDBResponse } from '../cmap/wire_protocol/responses';
 import { type Abortable } from '../mongo_types';
 import { ReadPreference, type ReadPreferenceLike } from '../read_preference';
-import type { Server } from '../sdam/server';
+import type { Server, ServerCommandOptions } from '../sdam/server';
 import type { ClientSession } from '../sessions';
 import { type TimeoutContext } from '../timeout';
 import type { MongoDBNamespace } from '../utils';
@@ -31,7 +33,6 @@ export interface OperationOptions extends BSONSerializeOptions {
 
   /** @internal Hints to `executeOperation` that this operation should not unpin on an ended transaction */
   bypassPinningCheck?: boolean;
-  omitReadPreference?: boolean;
 
   /** @internal Hint to `executeOperation` to omit maxTimeMS */
   omitMaxTimeMS?: boolean;
@@ -55,7 +56,6 @@ export abstract class AbstractOperation<TResult = any> {
   readPreference: ReadPreference;
   server!: Server;
   bypassPinningCheck: boolean;
-  trySecondaryWrite: boolean;
 
   // BSON serialization options
   bsonOptions?: BSONSerializeOptions;
@@ -81,7 +81,6 @@ export abstract class AbstractOperation<TResult = any> {
 
     this.options = options;
     this.bypassPinningCheck = !!options.bypassPinningCheck;
-    this.trySecondaryWrite = false;
   }
 
   /** Must match the first key of the command object sent to the server.
@@ -108,6 +107,10 @@ export abstract class AbstractOperation<TResult = any> {
     return this._session;
   }
 
+  set session(session: ClientSession) {
+    this._session = session;
+  }
+
   clearSession() {
     this._session = undefined;
   }
@@ -125,6 +128,59 @@ export abstract class AbstractOperation<TResult = any> {
   }
 }
 
+/** @internal */
+export abstract class ModernizedOperation<TResult> extends AbstractOperation<TResult> {
+  abstract SERVER_COMMAND_RESPONSE_TYPE: typeof MongoDBResponse;
+
+  /** this will never be used - but we must implement it to satisfy AbstractOperation's interface */
+  override execute(
+    _server: Server,
+    _session: ClientSession | undefined,
+    _timeoutContext: TimeoutContext
+  ): Promise<TResult> {
+    throw new Error('cannot execute!!');
+  }
+
+  /**
+   * Build a raw command document.
+   */
+  abstract buildCommand(connection: Connection, session?: ClientSession): Document;
+
+  /**
+   * Builds an instance of `ServerCommandOptions` to be used for operation execution.
+   */
+  abstract buildOptions(timeoutContext: TimeoutContext): ServerCommandOptions;
+
+  /**
+   * Given an instance of a MongoDBResponse, map the response to the correct result type.  For
+   * example, a `CountOperation` might map the response as follows:
+   *
+   * ```typescript
+   *  override handleOk(response: InstanceType<typeof this.SERVER_COMMAND_RESPONSE_TYPE>): TResult {
+   *    return response.toObject(this.bsonOptions).n ?? 0;
+   *  }
+   *
+   *  // or, with type safety:
+   *  override handleOk(response: InstanceType<typeof this.SERVER_COMMAND_RESPONSE_TYPE>): TResult {
+   *    return response.getNumber('n') ?? 0;
+   *  }
+   * ```
+   */
+  handleOk(response: InstanceType<typeof this.SERVER_COMMAND_RESPONSE_TYPE>): TResult {
+    return response.toObject(this.bsonOptions) as TResult;
+  }
+
+  /**
+   * Optional.
+   *
+   * If the operation performs error handling, such as wrapping, renaming the error, or squashing errors
+   * this method can be overridden.
+   */
+  handleError(error: MongoError): TResult | never {
+    throw error;
+  }
+}
+
 export function defineAspects(
   operation: { aspects?: Set<symbol> },
   aspects: symbol | symbol[] | Set<symbol>

package/src/operations/search_indexes/drop.ts

@@ -1,13 +1,17 @@
+import { type Connection, type MongoError } from '../..';
 import type { Document } from '../../bson';
+import { MongoDBResponse } from '../../cmap/wire_protocol/responses';
 import type { Collection } from '../../collection';
 import { MONGODB_ERROR_CODES, MongoServerError } from '../../error';
-import type { Server } from '../../sdam/server';
+import type { ServerCommandOptions } from '../../sdam/server';
 import type { ClientSession } from '../../sessions';
 import { type TimeoutContext } from '../../timeout';
-import { AbstractOperation } from '../operation';
+import { ModernizedOperation } from '../operation';
 
 /** @internal */
-export class DropSearchIndexOperation extends AbstractOperation<void> {
+export class DropSearchIndexOperation extends ModernizedOperation<void> {
+  override SERVER_COMMAND_RESPONSE_TYPE = MongoDBResponse;
+
   private readonly collection: Collection;
   private readonly name: string;
 
@@ -15,17 +19,14 @@ export class DropSearchIndexOperation extends AbstractOperation<void> {
     super();
     this.collection = collection;
     this.name = name;
+    this.ns = collection.fullNamespace;
   }
 
   override get commandName() {
     return 'dropSearchIndex' as const;
   }
 
-  override async execute(
-    server: Server,
-    session: ClientSession | undefined,
-    timeoutContext: TimeoutContext
-  ): Promise<void> {
+  override buildCommand(_connection: Connection, _session?: ClientSession): Document {
     const namespace = this.collection.fullNamespace;
 
     const command: Document = {
@@ -36,14 +37,22 @@ export class DropSearchIndexOperation extends AbstractOperation<void> {
       command.name = this.name;
     }
 
-    try {
-      await server.command(namespace, command, { session, timeoutContext });
-    } catch (error) {
-      const isNamespaceNotFoundError =
-        error instanceof MongoServerError && error.code === MONGODB_ERROR_CODES.NamespaceNotFound;
-      if (!isNamespaceNotFoundError) {
-        throw error;
-      }
+    return command;
+  }
+
+  override handleOk(_response: MongoDBResponse): void {
+    // do nothing
+  }
+
+  override buildOptions(timeoutContext: TimeoutContext): ServerCommandOptions {
+    return { session: this.session, timeoutContext };
+  }
+
+  override handleError(error: MongoError): void {
+    const isNamespaceNotFoundError =
+      error instanceof MongoServerError && error.code === MONGODB_ERROR_CODES.NamespaceNotFound;
+    if (!isNamespaceNotFoundError) {
+      throw error;
     }
   }
 }

package/src/sdam/server.ts

@@ -37,7 +37,9 @@ import {
 } from '../error';
 import type { ServerApi } from '../mongo_client';
 import { type Abortable, TypedEventEmitter } from '../mongo_types';
+import { AggregateOperation } from '../operations/aggregate';
 import type { GetMoreOptions } from '../operations/get_more';
+import { type ModernizedOperation } from '../operations/operation';
 import type { ClientSession } from '../sessions';
 import { type TimeoutContext } from '../timeout';
 import { isTransactionCommand } from '../transactions';
@@ -67,6 +69,7 @@ import type {
 } from './events';
 import { Monitor, type MonitorOptions } from './monitor';
 import { compareTopologyVersion, ServerDescription } from './server_description';
+import { MIN_SECONDARY_WRITE_WIRE_VERSION } from './server_selection';
 import type { Topology } from './topology';
 
 const stateTransition = makeStateMachine({
@@ -110,6 +113,7 @@ export type ServerEvents = {
 /** @internal */
 export type ServerCommandOptions = Omit<CommandOptions, 'timeoutContext' | 'socketTimeoutMS'> & {
   timeoutContext: TimeoutContext;
+  returnFieldSelector?: Document | null;
 } & Abortable;
 
 /** @internal */
@@ -277,6 +281,100 @@ export class Server extends TypedEventEmitter<ServerEvents> {
     }
   }
 
+  public async modernCommand<TResult>(
+    operation: ModernizedOperation<TResult>,
+    timeoutContext: TimeoutContext
+  ): Promise<InstanceType<typeof operation.SERVER_COMMAND_RESPONSE_TYPE>> {
+    if (this.s.state === STATE_CLOSING || this.s.state === STATE_CLOSED) {
+      throw new MongoServerClosedError();
+    }
+    const session = operation.session;
+
+    let conn = session?.pinnedConnection;
+
+    this.incrementOperationCount();
+    if (conn == null) {
+      try {
+        conn = await this.pool.checkOut({ timeoutContext });
+      } catch (checkoutError) {
+        this.decrementOperationCount();
+        if (!(checkoutError instanceof PoolClearedError)) this.handleError(checkoutError);
+        throw checkoutError;
+      }
+    }
+
+    const cmd = operation.buildCommand(conn, session);
+    const options = operation.buildOptions(timeoutContext);
+    const ns = operation.ns;
+
+    if (this.loadBalanced && isPinnableCommand(cmd, session) && !session?.pinnedConnection) {
+      session?.pin(conn);
+    }
+
+    options.directConnection = this.topology.s.options.directConnection;
+
+    const omitReadPreference =
+      operation instanceof AggregateOperation &&
+      operation.hasWriteStage &&
+      maxWireVersion(conn) < MIN_SECONDARY_WRITE_WIRE_VERSION;
+    if (omitReadPreference) {
+      delete options.readPreference;
+    }
+
+    if (this.description.iscryptd) {
+      options.omitMaxTimeMS = true;
+    }
+
+    let reauthPromise: Promise<void> | null = null;
+
+    try {
+      try {
+        const res = await conn.command(ns, cmd, options, operation.SERVER_COMMAND_RESPONSE_TYPE);
+        throwIfWriteConcernError(res);
+        return res;
+      } catch (commandError) {
+        throw this.decorateCommandError(conn, cmd, options, commandError);
+      }
+    } catch (operationError) {
+      if (
+        operationError instanceof MongoError &&
+        operationError.code === MONGODB_ERROR_CODES.Reauthenticate
+      ) {
+        reauthPromise = this.pool.reauthenticate(conn);
+        reauthPromise.then(undefined, error => {
+          reauthPromise = null;
+          squashError(error);
+        });
+
+        await abortable(reauthPromise, options);
+        reauthPromise = null; // only reachable if reauth succeeds
+
+        try {
+          const res = await conn.command(ns, cmd, options, operation.SERVER_COMMAND_RESPONSE_TYPE);
+          throwIfWriteConcernError(res);
+          return res;
+        } catch (commandError) {
+          throw this.decorateCommandError(conn, cmd, options, commandError);
+        }
+      } else {
+        throw operationError;
+      }
+    } finally {
+      this.decrementOperationCount();
+      if (session?.pinnedConnection !== conn) {
+        if (reauthPromise != null) {
+          // The reauth promise only exists if it hasn't thrown.
+          const checkBackIn = () => {
+            this.pool.checkIn(conn);
+          };
+          void reauthPromise.then(checkBackIn, checkBackIn);
+        } else {
+          this.pool.checkIn(conn);
+        }
+      }
+    }
+  }
+
   public async command<T extends MongoDBResponseConstructor>(
     ns: MongoDBNamespace,
     command: Document,
@@ -306,14 +404,6 @@ export class Server extends TypedEventEmitter<ServerEvents> {
 
     options.directConnection = this.topology.s.options.directConnection;
 
-    // There are cases where we need to flag the read preference not to get sent in
-    // the command, such as pre-5.0 servers attempting to perform an aggregate write
-    // with a non-primary read preference. In this case the effective read preference
-    // (primary) is not the same as the provided and must be removed completely.
-    if (options.omitReadPreference) {
-      delete options.readPreference;
-    }
-
     if (this.description.iscryptd) {
       options.omitMaxTimeMS = true;
     }

package/src/sdam/topology.ts

@@ -46,7 +46,6 @@ import {
   makeStateMachine,
   noop,
   now,
-  ns,
   promiseWithResolvers,
   shuffle
 } from '../utils';
@@ -459,7 +458,7 @@ export class Topology extends TypedEventEmitter<TopologyEvents> {
       waitQueueTimeoutMS: this.client.s.options.waitQueueTimeoutMS
     });
     const selectServerOptions = {
-      operationName: 'ping',
+      operationName: 'handshake',
       ...options,
       timeoutContext
     };
@@ -469,9 +468,11 @@ export class Topology extends TypedEventEmitter<TopologyEvents> {
         readPreferenceServerSelector(readPreference),
         selectServerOptions
       );
+
       const skipPingOnConnect = this.s.options.__skipPingOnConnect === true;
       if (!skipPingOnConnect && this.s.credentials) {
-        await server.command(ns('admin.$cmd'), { ping: 1 }, { timeoutContext });
+        const connection = await server.pool.checkOut({ timeoutContext: timeoutContext });
+        server.pool.checkIn(connection);
         stateTransition(this, STATE_CONNECTED);
         this.emit(Topology.OPEN, this);
         this.emit(Topology.CONNECT, this);