mongodb 6.18.0 → 6.19.0-dev.20250828.sha.41034f16

package/src/operations/search_indexes/update.ts

@@ -1,12 +1,15 @@
 import type { Document } from '../../bson';
+import { type Connection } from '../../cmap/connection';
+import { MongoDBResponse } from '../../cmap/wire_protocol/responses';
 import type { Collection } from '../../collection';
-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';
 
 /** @internal */
 export class UpdateSearchIndexOperation extends AbstractOperation<void> {
+  override SERVER_COMMAND_RESPONSE_TYPE = MongoDBResponse;
   private readonly collection: Collection;
   private readonly name: string;
   private readonly definition: Document;
@@ -16,25 +19,27 @@ export class UpdateSearchIndexOperation extends AbstractOperation<void> {
     this.collection = collection;
     this.name = name;
     this.definition = definition;
+    this.ns = collection.fullNamespace;
   }
 
   override get commandName() {
     return 'updateSearchIndex' 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 = {
+    return {
       updateSearchIndex: namespace.collection,
       name: this.name,
       definition: this.definition
     };
+  }
+
+  override handleOk(_response: MongoDBResponse): void {
+    // no response.
+  }
 
-    await server.command(namespace, command, { session, timeoutContext });
-    return;
+  override buildOptions(timeoutContext: TimeoutContext): ServerCommandOptions {
+    return { session: this.session, timeoutContext };
   }
 }

package/src/operations/set_profiling_level.ts

@@ -1,8 +1,8 @@
+import { type Document } from '../bson';
+import { type Connection } from '../cmap/connection';
+import { MongoDBResponse } from '../cmap/wire_protocol/responses';
 import type { Db } from '../db';
 import { MongoInvalidArgumentError } from '../error';
-import type { Server } from '../sdam/server';
-import type { ClientSession } from '../sessions';
-import { type TimeoutContext } from '../timeout';
 import { enumToString } from '../utils';
 import { CommandOperation, type CommandOperationOptions } from './command';
 
@@ -23,6 +23,7 @@ export type SetProfilingLevelOptions = CommandOperationOptions;
 
 /** @internal */
 export class SetProfilingLevelOperation extends CommandOperation<ProfilingLevel> {
+  override SERVER_COMMAND_RESPONSE_TYPE = MongoDBResponse;
   override options: SetProfilingLevelOptions;
   level: ProfilingLevel;
   profile: 0 | 1 | 2;
@@ -52,21 +53,22 @@ export class SetProfilingLevelOperation extends CommandOperation<ProfilingLevel>
     return 'profile' as const;
   }
 
-  override async execute(
-    server: Server,
-    session: ClientSession | undefined,
-    timeoutContext: TimeoutContext
-  ): Promise<ProfilingLevel> {
+  override buildCommandDocument(_connection: Connection): Document {
     const level = this.level;
 
     if (!levelValues.has(level)) {
+      // TODO(NODE-3483): Determine error to put here
       throw new MongoInvalidArgumentError(
         `Profiling level must be one of "${enumToString(ProfilingLevel)}"`
       );
     }
 
-    // TODO(NODE-3483): Determine error to put here
-    await super.executeCommand(server, session, { profile: this.profile }, timeoutContext);
-    return level;
+    return { profile: this.profile };
+  }
+
+  override handleOk(
+    _response: InstanceType<typeof this.SERVER_COMMAND_RESPONSE_TYPE>
+  ): ProfilingLevel {
+    return this.level;
   }
 }

package/src/operations/stats.ts

@@ -1,8 +1,7 @@
 import type { Document } from '../bson';
+import { type Connection } from '../cmap/connection';
+import { MongoDBResponse } from '../cmap/wire_protocol/responses';
 import type { Db } from '../db';
-import type { Server } from '../sdam/server';
-import type { ClientSession } from '../sessions';
-import { type TimeoutContext } from '../timeout';
 import { CommandOperation, type CommandOperationOptions } from './command';
 import { Aspect, defineAspects } from './operation';
 
@@ -14,6 +13,7 @@ export interface DbStatsOptions extends CommandOperationOptions {
 
 /** @internal */
 export class DbStatsOperation extends CommandOperation<Document> {
+  override SERVER_COMMAND_RESPONSE_TYPE = MongoDBResponse;
   override options: DbStatsOptions;
 
   constructor(db: Db, options: DbStatsOptions) {
@@ -25,17 +25,12 @@ export class DbStatsOperation extends CommandOperation<Document> {
     return 'dbStats' as const;
   }
 
-  override async execute(
-    server: Server,
-    session: ClientSession | undefined,
-    timeoutContext: TimeoutContext
-  ): Promise<Document> {
+  override buildCommandDocument(_connection: Connection): Document {
     const command: Document = { dbStats: true };
     if (this.options.scale != null) {
       command.scale = this.options.scale;
     }
-
-    return await super.executeCommand(server, session, command, timeoutContext);
+    return command;
   }
 }
 

package/src/operations/update.ts

@@ -1,12 +1,15 @@
 import type { Document } from '../bson';
-import type { Collection } from '../collection';
+import { type Connection } from '../cmap/connection';
+import { MongoDBResponse } from '../cmap/wire_protocol/responses';
 import { MongoCompatibilityError, MongoInvalidArgumentError, MongoServerError } from '../error';
-import type { InferIdType, TODO_NODE_3286 } from '../mongo_types';
-import type { Server } from '../sdam/server';
+import type { InferIdType } from '../mongo_types';
 import type { ClientSession } from '../sessions';
 import { formatSort, type Sort, type SortForCmd } from '../sort';
-import { type TimeoutContext } from '../timeout';
-import { hasAtomicOperators, type MongoDBNamespace } from '../utils';
+import {
+  hasAtomicOperators,
+  type MongoDBCollectionNamespace,
+  type MongoDBNamespace
+} from '../utils';
 import { type CollationOptions, CommandOperation, type CommandOperationOptions } from './command';
 import { Aspect, defineAspects, type Hint } from './operation';
 
@@ -68,6 +71,7 @@ export interface UpdateStatement {
  * UpdateOperation is used in bulk write, while UpdateOneOperation and UpdateManyOperation are only used in the collections API
  */
 export class UpdateOperation extends CommandOperation<Document> {
+  override SERVER_COMMAND_RESPONSE_TYPE = MongoDBResponse;
   override options: UpdateOptions & { ordered?: boolean };
   statements: UpdateStatement[];
 
@@ -95,17 +99,12 @@ export class UpdateOperation extends CommandOperation<Document> {
     return this.statements.every(op => op.multi == null || op.multi === false);
   }
 
-  override async execute(
-    server: Server,
-    session: ClientSession | undefined,
-    timeoutContext: TimeoutContext
-  ): Promise<Document> {
-    const options = this.options ?? {};
-    const ordered = typeof options.ordered === 'boolean' ? options.ordered : true;
+  override buildCommandDocument(_connection: Connection, _session?: ClientSession): Document {
+    const options = this.options;
     const command: Document = {
       update: this.ns.collection,
       updates: this.statements,
-      ordered
+      ordered: options.ordered ?? true
     };
 
     if (typeof options.bypassDocumentValidation === 'boolean') {
@@ -122,7 +121,7 @@ export class UpdateOperation extends CommandOperation<Document> {
       command.comment = options.comment;
     }
 
-    const unacknowledgedWrite = this.writeConcern && this.writeConcern.w === 0;
+    const unacknowledgedWrite = this.writeConcern?.w === 0;
     if (unacknowledgedWrite) {
       if (this.statements.find((o: Document) => o.hint)) {
         // TODO(NODE-3541): fix error for hint with unacknowledged writes
@@ -130,32 +129,33 @@ export class UpdateOperation extends CommandOperation<Document> {
       }
     }
 
-    const res = await super.executeCommand(server, session, command, timeoutContext);
-    return res;
+    return command;
   }
 }
 
 /** @internal */
 export class UpdateOneOperation extends UpdateOperation {
-  constructor(collection: Collection, filter: Document, update: Document, options: UpdateOptions) {
-    super(
-      collection.s.namespace,
-      [makeUpdateStatement(filter, update, { ...options, multi: false })],
-      options
-    );
+  constructor(
+    ns: MongoDBCollectionNamespace,
+    filter: Document,
+    update: Document,
+    options: UpdateOptions
+  ) {
+    super(ns, [makeUpdateStatement(filter, update, { ...options, multi: false })], options);
 
     if (!hasAtomicOperators(update, options)) {
       throw new MongoInvalidArgumentError('Update document requires atomic operators');
     }
   }
 
-  override async execute(
-    server: Server,
-    session: ClientSession | undefined,
-    timeoutContext: TimeoutContext
-  ): Promise<UpdateResult> {
-    const res: TODO_NODE_3286 = await super.execute(server, session, timeoutContext);
+  override handleOk(
+    response: InstanceType<typeof this.SERVER_COMMAND_RESPONSE_TYPE>
+  ): UpdateResult {
+    const res = super.handleOk(response);
+
+    // @ts-expect-error Explain typing is broken
     if (this.explain != null) return res;
+
     if (res.code) throw new MongoServerError(res);
     if (res.writeErrors) throw new MongoServerError(res.writeErrors[0]);
 
@@ -172,24 +172,25 @@ export class UpdateOneOperation extends UpdateOperation {
 
 /** @internal */
 export class UpdateManyOperation extends UpdateOperation {
-  constructor(collection: Collection, filter: Document, update: Document, options: UpdateOptions) {
-    super(
-      collection.s.namespace,
-      [makeUpdateStatement(filter, update, { ...options, multi: true })],
-      options
-    );
+  constructor(
+    ns: MongoDBCollectionNamespace,
+    filter: Document,
+    update: Document,
+    options: UpdateOptions
+  ) {
+    super(ns, [makeUpdateStatement(filter, update, { ...options, multi: true })], options);
 
     if (!hasAtomicOperators(update, options)) {
       throw new MongoInvalidArgumentError('Update document requires atomic operators');
     }
   }
 
-  override async execute(
-    server: Server,
-    session: ClientSession | undefined,
-    timeoutContext: TimeoutContext
-  ): Promise<UpdateResult> {
-    const res: TODO_NODE_3286 = await super.execute(server, session, timeoutContext);
+  override handleOk(
+    response: InstanceType<typeof this.SERVER_COMMAND_RESPONSE_TYPE>
+  ): UpdateResult {
+    const res = super.handleOk(response);
+
+    // @ts-expect-error Explain typing is broken
     if (this.explain != null) return res;
     if (res.code) throw new MongoServerError(res);
     if (res.writeErrors) throw new MongoServerError(res.writeErrors[0]);
@@ -224,28 +225,24 @@ export interface ReplaceOptions extends CommandOperationOptions {
 /** @internal */
 export class ReplaceOneOperation extends UpdateOperation {
   constructor(
-    collection: Collection,
+    ns: MongoDBCollectionNamespace,
     filter: Document,
     replacement: Document,
     options: ReplaceOptions
   ) {
-    super(
-      collection.s.namespace,
-      [makeUpdateStatement(filter, replacement, { ...options, multi: false })],
-      options
-    );
+    super(ns, [makeUpdateStatement(filter, replacement, { ...options, multi: false })], options);
 
     if (hasAtomicOperators(replacement)) {
       throw new MongoInvalidArgumentError('Replacement document must not contain atomic operators');
     }
   }
 
-  override async execute(
-    server: Server,
-    session: ClientSession | undefined,
-    timeoutContext: TimeoutContext
-  ): Promise<UpdateResult> {
-    const res: TODO_NODE_3286 = await super.execute(server, session, timeoutContext);
+  override handleOk(
+    response: InstanceType<typeof this.SERVER_COMMAND_RESPONSE_TYPE>
+  ): UpdateResult {
+    const res = super.handleOk(response);
+
+    // @ts-expect-error Explain typing is broken
     if (this.explain != null) return res;
     if (res.code) throw new MongoServerError(res);
     if (res.writeErrors) throw new MongoServerError(res.writeErrors[0]);

package/src/operations/validate_collection.ts

@@ -1,9 +1,9 @@
+import { type Connection } from '..';
 import type { Admin } from '../admin';
-import type { Document } from '../bson';
+import { type Document } from '../bson';
+import { MongoDBResponse } from '../cmap/wire_protocol/responses';
 import { MongoUnexpectedServerResponseError } from '../error';
-import type { Server } from '../sdam/server';
 import type { ClientSession } from '../sessions';
-import { type TimeoutContext } from '../timeout';
 import { CommandOperation, type CommandOperationOptions } from './command';
 
 /** @public */
@@ -14,23 +14,13 @@ export interface ValidateCollectionOptions extends CommandOperationOptions {
 
 /** @internal */
 export class ValidateCollectionOperation extends CommandOperation<Document> {
+  override SERVER_COMMAND_RESPONSE_TYPE = MongoDBResponse;
   override options: ValidateCollectionOptions;
   collectionName: string;
-  command: Document;
 
   constructor(admin: Admin, collectionName: string, options: ValidateCollectionOptions) {
-    // Decorate command with extra options
-    const command: Document = { validate: collectionName };
-    const keys = Object.keys(options);
-    for (let i = 0; i < keys.length; i++) {
-      if (Object.prototype.hasOwnProperty.call(options, keys[i]) && keys[i] !== 'session') {
-        command[keys[i]] = (options as Document)[keys[i]];
-      }
-    }
-
     super(admin.s.db, options);
     this.options = options;
-    this.command = command;
     this.collectionName = collectionName;
   }
 
@@ -38,21 +28,23 @@ export class ValidateCollectionOperation extends CommandOperation<Document> {
     return 'validate' as const;
   }
 
-  override async execute(
-    server: Server,
-    session: ClientSession | undefined,
-    timeoutContext: TimeoutContext
-  ): Promise<Document> {
-    const collectionName = this.collectionName;
+  override buildCommandDocument(_connection: Connection, _session?: ClientSession): Document {
+    // Decorate command with extra options
+    return {
+      validate: this.collectionName,
+      ...Object.fromEntries(Object.entries(this.options).filter(entry => entry[0] !== 'session'))
+    };
+  }
 
-    const doc = await super.executeCommand(server, session, this.command, timeoutContext);
-    if (doc.result != null && typeof doc.result !== 'string')
+  override handleOk(response: InstanceType<typeof this.SERVER_COMMAND_RESPONSE_TYPE>): Document {
+    const result = super.handleOk(response);
+    if (result.result != null && typeof result.result !== 'string')
       throw new MongoUnexpectedServerResponseError('Error with validation data');
-    if (doc.result != null && doc.result.match(/exception|corrupt/) != null)
-      throw new MongoUnexpectedServerResponseError(`Invalid collection ${collectionName}`);
-    if (doc.valid != null && !doc.valid)
-      throw new MongoUnexpectedServerResponseError(`Invalid collection ${collectionName}`);
+    if (result.result != null && result.result.match(/exception|corrupt/) != null)
+      throw new MongoUnexpectedServerResponseError(`Invalid collection ${this.collectionName}`);
+    if (result.valid != null && !result.valid)
+      throw new MongoUnexpectedServerResponseError(`Invalid collection ${this.collectionName}`);
 
-    return doc;
+    return response;
   }
 }

package/src/sdam/server.ts

@@ -7,7 +7,6 @@ import {
   type ConnectionPoolOptions
 } from '../cmap/connection_pool';
 import { PoolClearedError } from '../cmap/errors';
-import { type MongoDBResponseConstructor } from '../cmap/wire_protocol/responses';
 import {
   APM_EVENTS,
   CLOSED,
@@ -27,7 +26,6 @@ import {
   MONGODB_ERROR_CODES,
   MongoError,
   MongoErrorLabel,
-  MongoInvalidArgumentError,
   MongoNetworkError,
   MongoNetworkTimeoutError,
   MongoRuntimeError,
@@ -37,7 +35,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 AbstractOperation } from '../operations/operation';
 import type { ClientSession } from '../sessions';
 import { type TimeoutContext } from '../timeout';
 import { isTransactionCommand } from '../transactions';
@@ -46,7 +46,6 @@ import {
   type EventEmitterWithState,
   makeStateMachine,
   maxWireVersion,
-  type MongoDBNamespace,
   noop,
   squashError,
   supportsRetryableWrites
@@ -67,6 +66,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 +110,7 @@ export type ServerEvents = {
 /** @internal */
 export type ServerCommandOptions = Omit<CommandOptions, 'timeoutContext' | 'socketTimeoutMS'> & {
   timeoutContext: TimeoutContext;
+  returnFieldSelector?: Document | null;
 } & Abortable;
 
 /** @internal */
@@ -277,57 +278,21 @@ export class Server extends TypedEventEmitter<ServerEvents> {
     }
   }
 
-  public async command<T extends MongoDBResponseConstructor>(
-    ns: MongoDBNamespace,
-    command: Document,
-    options: ServerCommandOptions,
-    responseType: T | undefined
-  ): Promise<typeof responseType extends undefined ? Document : InstanceType<T>>;
-
-  public async command(
-    ns: MongoDBNamespace,
-    command: Document,
-    options: ServerCommandOptions
-  ): Promise<Document>;
-
-  public async command(
-    ns: MongoDBNamespace,
-    cmd: Document,
-    { ...options }: ServerCommandOptions,
-    responseType?: MongoDBResponseConstructor
-  ): Promise<Document> {
-    if (ns.db == null || typeof ns === 'string') {
-      throw new MongoInvalidArgumentError('Namespace must not be a string');
-    }
-
+  public async command<TResult>(
+    operation: AbstractOperation<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;
 
-    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;
-    }
-
-    const session = options.session;
     let conn = session?.pinnedConnection;
 
     this.incrementOperationCount();
     if (conn == null) {
       try {
-        conn = await this.pool.checkOut(options);
-        if (this.loadBalanced && isPinnableCommand(cmd, session)) {
-          session?.pin(conn);
-        }
+        conn = await this.pool.checkOut({ timeoutContext, signal: operation.options.signal });
       } catch (checkoutError) {
         this.decrementOperationCount();
         if (!(checkoutError instanceof PoolClearedError)) this.handleError(checkoutError);
@@ -336,10 +301,53 @@ export class Server extends TypedEventEmitter<ServerEvents> {
     }
 
     let reauthPromise: Promise<void> | null = null;
+    const cleanup = () => {
+      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);
+        }
+      }
+    };
+
+    let cmd;
+    try {
+      cmd = operation.buildCommand(conn, session);
+    } catch (e) {
+      cleanup();
+      throw e;
+    }
+
+    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;
+    }
 
     try {
       try {
-        const res = await conn.command(ns, cmd, options, responseType);
+        const res = await conn.command(ns, cmd, options, operation.SERVER_COMMAND_RESPONSE_TYPE);
         throwIfWriteConcernError(res);
         return res;
       } catch (commandError) {
@@ -360,7 +368,7 @@ export class Server extends TypedEventEmitter<ServerEvents> {
         reauthPromise = null; // only reachable if reauth succeeds
 
         try {
-          const res = await conn.command(ns, cmd, options, responseType);
+          const res = await conn.command(ns, cmd, options, operation.SERVER_COMMAND_RESPONSE_TYPE);
           throwIfWriteConcernError(res);
           return res;
         } catch (commandError) {
@@ -370,18 +378,7 @@ export class Server extends TypedEventEmitter<ServerEvents> {
         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);
-        }
-      }
+      cleanup();
     }
   }
 

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);
@@ -749,7 +750,7 @@ export class Topology extends TypedEventEmitter<TopologyEvents> {
   }
 
   auth(credentials?: MongoCredentials, callback?: Callback): void {
-    if (typeof credentials === 'function') (callback = credentials), (credentials = undefined);
+    if (typeof credentials === 'function') ((callback = credentials), (credentials = undefined));
     if (typeof callback === 'function') callback(undefined, true);
   }
 

package/src/sessions.ts

@@ -24,7 +24,7 @@ import {
 import type { MongoClient, MongoOptions } from './mongo_client';
 import { TypedEventEmitter } from './mongo_types';
 import { executeOperation } from './operations/execute_operation';
-import { RunAdminCommandOperation } from './operations/run_command';
+import { RunCommandOperation } from './operations/run_command';
 import { ReadConcernLevel } from './read_concern';
 import { ReadPreference } from './read_preference';
 import { type AsyncDisposable, configureResourceManagement } from './resource_management';
@@ -43,6 +43,7 @@ import {
   isPromiseLike,
   List,
   maxWireVersion,
+  MongoDBNamespace,
   noop,
   now,
   squashError,
@@ -505,7 +506,7 @@ export class ClientSession
       command.recoveryToken = this.transaction.recoveryToken;
     }
 
-    const operation = new RunAdminCommandOperation(command, {
+    const operation = new RunCommandOperation(new MongoDBNamespace('admin'), command, {
       session: this,
       readPreference: ReadPreference.primary,
       bypassPinningCheck: true
@@ -536,7 +537,7 @@ export class ClientSession
         try {
           await executeOperation(
             this.client,
-            new RunAdminCommandOperation(command, {
+            new RunCommandOperation(new MongoDBNamespace('admin'), command, {
               session: this,
               readPreference: ReadPreference.primary,
               bypassPinningCheck: true
@@ -637,7 +638,7 @@ export class ClientSession
       command.recoveryToken = this.transaction.recoveryToken;
     }
 
-    const operation = new RunAdminCommandOperation(command, {
+    const operation = new RunCommandOperation(new MongoDBNamespace('admin'), command, {
       session: this,
       readPreference: ReadPreference.primary,
       bypassPinningCheck: true