mongodb 6.18.0-dev.20250823.sha.c2166a50 → 6.18.0-dev.20250826.sha.66706f8e

package/src/operations/delete.ts

@@ -5,11 +5,7 @@ import { MongoCompatibilityError, MongoServerError } from '../error';
 import type { ClientSession } from '../sessions';
 import { type MongoDBCollectionNamespace, type MongoDBNamespace } from '../utils';
 import { type WriteConcernOptions } from '../write_concern';
-import {
-  type CollationOptions,
-  type CommandOperationOptions,
-  ModernizedCommandOperation
-} from './command';
+import { type CollationOptions, CommandOperation, type CommandOperationOptions } from './command';
 import { Aspect, defineAspects, type Hint } from './operation';
 
 /** @public */
@@ -45,7 +41,7 @@ export interface DeleteStatement {
 }
 
 /** @internal */
-export class DeleteOperation extends ModernizedCommandOperation<Document> {
+export class DeleteOperation extends CommandOperation<Document> {
   override SERVER_COMMAND_RESPONSE_TYPE = MongoDBResponse;
   override options: DeleteOptions;
   statements: DeleteStatement[];

package/src/operations/distinct.ts

@@ -1,9 +1,7 @@
-import type { Document } from '../bson';
+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 { ClientSession } from '../sessions';
-import { type TimeoutContext } from '../timeout';
-import { decorateWithCollation, decorateWithReadConcern } from '../utils';
 import { CommandOperation, type CommandOperationOptions } from './command';
 import { Aspect, defineAspects } from './operation';
 
@@ -27,7 +25,8 @@ export type DistinctOptions = CommandOperationOptions & {
  * Return a list of distinct values for the given key across a collection.
  * @internal
  */
-export class DistinctOperation extends CommandOperation<any[]> {
+export class DistinctOperation extends CommandOperation<any[] | Document> {
+  override SERVER_COMMAND_RESPONSE_TYPE = MongoDBResponse;
   override options: DistinctOptions;
   collection: Collection;
   /** Field of the document to find distinct values for. */
@@ -56,48 +55,32 @@ export class DistinctOperation extends CommandOperation<any[]> {
     return 'distinct' as const;
   }
 
-  override async execute(
-    server: Server,
-    session: ClientSession | undefined,
-    timeoutContext: TimeoutContext
-  ): Promise<any[]> {
-    const coll = this.collection;
-    const key = this.key;
-    const query = this.query;
-    const options = this.options;
-
-    // Distinct command
-    const cmd: Document = {
-      distinct: coll.collectionName,
-      key: key,
-      query: query
+  override buildCommandDocument(_connection: Connection): Document {
+    const command: Document = {
+      distinct: this.collection.collectionName,
+      key: this.key,
+      query: this.query
     };
-
-    // Add maxTimeMS if defined
-    if (typeof options.maxTimeMS === 'number') {
-      cmd.maxTimeMS = options.maxTimeMS;
-    }
-
     // we check for undefined specifically here to allow falsy values
     // eslint-disable-next-line no-restricted-syntax
-    if (typeof options.comment !== 'undefined') {
-      cmd.comment = options.comment;
+    if (this.options.comment !== undefined) {
+      command.comment = this.options.comment;
     }
 
-    if (options.hint != null) {
-      cmd.hint = options.hint;
+    if (this.options.hint != null) {
+      command.hint = this.options.hint;
     }
 
-    // Do we have a readConcern specified
-    decorateWithReadConcern(cmd, coll, options);
-
-    // Have we specified collation
-    decorateWithCollation(cmd, coll, options);
-
-    const result = await super.executeCommand(server, session, cmd, timeoutContext);
+    return command;
+  }
 
-    // @ts-expect-error: Explain always returns a document
-    return this.explain ? result : result.values;
+  override handleOk(
+    response: InstanceType<typeof this.SERVER_COMMAND_RESPONSE_TYPE>
+  ): any[] | Document {
+    if (this.explain) {
+      return response.toObject(this.bsonOptions);
+    }
+    return response.toObject(this.bsonOptions).values;
   }
 }
 

package/src/operations/drop.ts

@@ -6,7 +6,7 @@ import type { Db } from '../db';
 import { MONGODB_ERROR_CODES } from '../error';
 import type { ClientSession } from '../sessions';
 import { TimeoutContext } from '../timeout';
-import { type CommandOperationOptions, ModernizedCommandOperation } from './command';
+import { CommandOperation, type CommandOperationOptions } from './command';
 import { executeOperation } from './execute_operation';
 import { Aspect, defineAspects } from './operation';
 
@@ -17,7 +17,7 @@ export interface DropCollectionOptions extends CommandOperationOptions {
 }
 
 /** @internal */
-export class DropCollectionOperation extends ModernizedCommandOperation<boolean> {
+export class DropCollectionOperation extends CommandOperation<boolean> {
   override SERVER_COMMAND_RESPONSE_TYPE = MongoDBResponse;
 
   override options: DropCollectionOptions;
@@ -107,7 +107,7 @@ export async function dropCollections(
 export type DropDatabaseOptions = CommandOperationOptions;
 
 /** @internal */
-export class DropDatabaseOperation extends ModernizedCommandOperation<boolean> {
+export class DropDatabaseOperation extends CommandOperation<boolean> {
   override SERVER_COMMAND_RESPONSE_TYPE = MongoDBResponse;
   override options: DropDatabaseOptions;
 

package/src/operations/estimated_document_count.ts

@@ -3,7 +3,7 @@ import type { Document } from '../bson';
 import { MongoDBResponse } from '../cmap/wire_protocol/responses';
 import type { Collection } from '../collection';
 import type { ClientSession } from '../sessions';
-import { type CommandOperationOptions, ModernizedCommandOperation } from './command';
+import { CommandOperation, type CommandOperationOptions } from './command';
 import { Aspect, defineAspects } from './operation';
 
 /** @public */
@@ -17,7 +17,7 @@ export interface EstimatedDocumentCountOptions extends CommandOperationOptions {
 }
 
 /** @internal */
-export class EstimatedDocumentCountOperation extends ModernizedCommandOperation<number> {
+export class EstimatedDocumentCountOperation extends CommandOperation<number> {
   override SERVER_COMMAND_RESPONSE_TYPE = MongoDBResponse;
   override options: EstimatedDocumentCountOptions;
   collectionName: string;

package/src/operations/execute_operation.ts

@@ -27,18 +27,15 @@ import type { ClientSession } from '../sessions';
 import { TimeoutContext } from '../timeout';
 import { abortable, supportsRetryableWrites } from '../utils';
 import { AggregateOperation } from './aggregate';
-import { AbstractOperation, Aspect, ModernizedOperation } from './operation';
+import { AbstractOperation, Aspect } from './operation';
 
 const MMAPv1_RETRY_WRITES_ERROR_CODE = MONGODB_ERROR_CODES.IllegalOperation;
 const MMAPv1_RETRY_WRITES_ERROR_MESSAGE =
   'This MongoDB deployment does not support retryable writes. Please add retryWrites=false to your connection string.';
 
-type ResultTypeFromOperation<TOperation> =
-  TOperation extends ModernizedOperation<infer _>
-    ? ReturnType<TOperation['handleOk']>
-    : TOperation extends AbstractOperation<infer K>
-      ? K
-      : never;
+type ResultTypeFromOperation<TOperation extends AbstractOperation> = ReturnType<
+  TOperation['handleOk']
+>;
 
 /**
  * Executes the given operation with provided arguments.
@@ -235,8 +232,6 @@ async function tryOperation<T extends AbstractOperation, TResult = ResultTypeFro
   let previousOperationError: MongoError | undefined;
   let previousServer: ServerDescription | undefined;
 
-  const isModernOperation = operation instanceof ModernizedOperation;
-
   for (let tries = 0; tries < maxTries; tries++) {
     if (previousOperationError) {
       if (hasWriteAspect && previousOperationError.code === MMAPv1_RETRY_WRITES_ERROR_CODE) {
@@ -290,12 +285,8 @@ async function tryOperation<T extends AbstractOperation, TResult = ResultTypeFro
         operation.resetBatch();
       }
 
-      if (!isModernOperation) {
-        return await operation.execute(server, session, timeoutContext);
-      }
-
       try {
-        const result = await server.modernCommand(operation, timeoutContext);
+        const result = await server.command(operation, timeoutContext);
         return operation.handleOk(result);
       } catch (error) {
         return operation.handleError(error);

package/src/operations/find.ts

@@ -7,11 +7,7 @@ import type { ServerCommandOptions } from '../sdam/server';
 import { formatSort, type Sort } from '../sort';
 import { type TimeoutContext } from '../timeout';
 import { type MongoDBNamespace, normalizeHintField } from '../utils';
-import {
-  type CollationOptions,
-  type CommandOperationOptions,
-  ModernizedCommandOperation
-} from './command';
+import { type CollationOptions, CommandOperation, type CommandOperationOptions } from './command';
 import { Aspect, defineAspects, type Hint } from './operation';
 
 /**
@@ -90,7 +86,7 @@ export interface FindOneOptions extends FindOptions {
 }
 
 /** @internal */
-export class FindOperation extends ModernizedCommandOperation<CursorResponse> {
+export class FindOperation extends CommandOperation<CursorResponse> {
   override SERVER_COMMAND_RESPONSE_TYPE = CursorResponse;
 
   /**

package/src/operations/find_and_modify.ts

@@ -8,7 +8,7 @@ import type { ClientSession } from '../sessions';
 import { formatSort, type Sort, type SortForCmd } from '../sort';
 import { decorateWithCollation, hasAtomicOperators } from '../utils';
 import { type WriteConcern, type WriteConcernSettings } from '../write_concern';
-import { type CommandOperationOptions, ModernizedCommandOperation } from './command';
+import { CommandOperation, type CommandOperationOptions } from './command';
 import { Aspect, defineAspects } from './operation';
 
 /** @public */
@@ -120,7 +120,7 @@ function configureFindAndModifyCmdBaseUpdateOpts(
 }
 
 /** @internal */
-export class FindAndModifyOperation extends ModernizedCommandOperation<Document> {
+export class FindAndModifyOperation extends CommandOperation<Document> {
   override SERVER_COMMAND_RESPONSE_TYPE = MongoDBResponse;
   override options: FindOneAndReplaceOptions | FindOneAndUpdateOptions | FindOneAndDeleteOptions;
   collection: Collection;

package/src/operations/get_more.ts

@@ -5,7 +5,7 @@ import { MongoRuntimeError } from '../error';
 import type { Server, ServerCommandOptions } from '../sdam/server';
 import { type TimeoutContext } from '../timeout';
 import { maxWireVersion, type MongoDBNamespace } from '../utils';
-import { Aspect, defineAspects, ModernizedOperation, type OperationOptions } from './operation';
+import { AbstractOperation, Aspect, defineAspects, type OperationOptions } from './operation';
 
 /** @internal */
 export interface GetMoreOptions extends OperationOptions {
@@ -37,7 +37,7 @@ export interface GetMoreCommand {
 }
 
 /** @internal */
-export class GetMoreOperation extends ModernizedOperation<CursorResponse> {
+export class GetMoreOperation extends AbstractOperation<CursorResponse> {
   override SERVER_COMMAND_RESPONSE_TYPE = CursorResponse;
   cursorId: Long;
   override options: GetMoreOptions;

package/src/operations/indexes.ts

@@ -8,8 +8,8 @@ import { type OneOrMore } from '../mongo_types';
 import { isObject, maxWireVersion, type MongoDBNamespace } from '../utils';
 import {
   type CollationOptions,
+  CommandOperation,
   type CommandOperationOptions,
-  ModernizedCommandOperation,
   type OperationParent
 } from './command';
 import { Aspect, defineAspects } from './operation';
@@ -242,7 +242,7 @@ type ResolvedIndexDescription = Omit<IndexDescription, 'key' | 'version'> & {
 };
 
 /** @internal */
-export class CreateIndexesOperation extends ModernizedCommandOperation<string[]> {
+export class CreateIndexesOperation extends CommandOperation<string[]> {
   override SERVER_COMMAND_RESPONSE_TYPE = MongoDBResponse;
   override options: CreateIndexesOptions;
   collectionName: string;
@@ -328,7 +328,7 @@ export class CreateIndexesOperation extends ModernizedCommandOperation<string[]>
 export type DropIndexesOptions = CommandOperationOptions;
 
 /** @internal */
-export class DropIndexOperation extends ModernizedCommandOperation<Document> {
+export class DropIndexOperation extends CommandOperation<Document> {
   override SERVER_COMMAND_RESPONSE_TYPE = MongoDBResponse;
   override options: DropIndexesOptions;
   collection: Collection;
@@ -359,7 +359,7 @@ export type ListIndexesOptions = AbstractCursorOptions & {
 };
 
 /** @internal */
-export class ListIndexesOperation extends ModernizedCommandOperation<CursorResponse> {
+export class ListIndexesOperation extends CommandOperation<CursorResponse> {
   override SERVER_COMMAND_RESPONSE_TYPE = CursorResponse;
   /**
    * @remarks WriteConcern can still be present on the options because

package/src/operations/insert.ts

@@ -7,10 +7,10 @@ import { MongoServerError } from '../error';
 import type { InferIdType } from '../mongo_types';
 import type { ClientSession } from '../sessions';
 import { maybeAddIdToDocuments, type MongoDBNamespace } from '../utils';
-import { type CommandOperationOptions, ModernizedCommandOperation } from './command';
+import { CommandOperation, type CommandOperationOptions } from './command';
 import { Aspect, defineAspects } from './operation';
 /** @internal */
-export class InsertOperation extends ModernizedCommandOperation<Document> {
+export class InsertOperation extends CommandOperation<Document> {
   override SERVER_COMMAND_RESPONSE_TYPE = MongoDBResponse;
   override options: BulkWriteOptions;
 

package/src/operations/kill_cursors.ts

@@ -6,7 +6,7 @@ import type { Server, ServerCommandOptions } from '../sdam/server';
 import type { ClientSession } from '../sessions';
 import { type TimeoutContext } from '../timeout';
 import { type MongoDBNamespace } from '../utils';
-import { Aspect, defineAspects, ModernizedOperation, type OperationOptions } from './operation';
+import { AbstractOperation, Aspect, defineAspects, type OperationOptions } from './operation';
 
 /**
  * https://www.mongodb.com/docs/manual/reference/command/killCursors/
@@ -18,7 +18,7 @@ interface KillCursorsCommand {
   comment?: unknown;
 }
 
-export class KillCursorsOperation extends ModernizedOperation<void> {
+export class KillCursorsOperation extends AbstractOperation<void> {
   override SERVER_COMMAND_RESPONSE_TYPE = MongoDBResponse;
   cursorId: Long;
 

package/src/operations/list_collections.ts

@@ -5,7 +5,7 @@ import { type CursorTimeoutContext, type CursorTimeoutMode } from '../cursor/abs
 import type { Db } from '../db';
 import { type Abortable } from '../mongo_types';
 import { maxWireVersion } from '../utils';
-import { type CommandOperationOptions, ModernizedCommandOperation } from './command';
+import { CommandOperation, type CommandOperationOptions } from './command';
 import { Aspect, defineAspects } from './operation';
 
 /** @public */
@@ -26,7 +26,7 @@ export interface ListCollectionsOptions
 }
 
 /** @internal */
-export class ListCollectionsOperation extends ModernizedCommandOperation<CursorResponse> {
+export class ListCollectionsOperation extends CommandOperation<CursorResponse> {
   override SERVER_COMMAND_RESPONSE_TYPE = CursorResponse;
   /**
    * @remarks WriteConcern can still be present on the options because

package/src/operations/list_databases.ts

@@ -4,7 +4,7 @@ import { MongoDBResponse } from '../cmap/wire_protocol/responses';
 import type { Db } from '../db';
 import type { ClientSession } from '../sessions';
 import { maxWireVersion, MongoDBNamespace } from '../utils';
-import { type CommandOperationOptions, ModernizedCommandOperation } from './command';
+import { CommandOperation, type CommandOperationOptions } from './command';
 import { Aspect, defineAspects } from './operation';
 
 /** @public */
@@ -26,7 +26,7 @@ export interface ListDatabasesOptions extends CommandOperationOptions {
 }
 
 /** @internal */
-export class ListDatabasesOperation extends ModernizedCommandOperation<ListDatabasesResult> {
+export class ListDatabasesOperation extends CommandOperation<ListDatabasesResult> {
   override SERVER_COMMAND_RESPONSE_TYPE = MongoDBResponse;
   override options: ListDatabasesOptions;
 

package/src/operations/operation.ts

@@ -87,12 +87,6 @@ export abstract class AbstractOperation<TResult = any> {
   Command name should be stateless (should not use 'this' keyword) */
   abstract get commandName(): string;
 
-  abstract execute(
-    server: Server,
-    session: ClientSession | undefined,
-    timeoutContext: TimeoutContext
-  ): Promise<TResult>;
-
   hasAspect(aspect: symbol): boolean {
     const ctor = this.constructor as { aspects?: Set<symbol> };
     if (ctor.aspects == null) {
@@ -126,21 +120,8 @@ export abstract class AbstractOperation<TResult = any> {
   get canRetryWrite(): boolean {
     return this.hasAspect(Aspect.RETRYABLE) && this.hasAspect(Aspect.WRITE_OPERATION);
   }
-}
-
-/** @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.
    */

package/src/operations/profiling_level.ts

@@ -1,15 +1,22 @@
+import { BSONType, type Document } from '../bson';
+import { type Connection } from '../cmap/connection';
+import { MongoDBResponse } from '../cmap/wire_protocol/responses';
 import type { Db } from '../db';
 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 */
 export type ProfilingLevelOptions = CommandOperationOptions;
 
+class ProfilingLevelResponse extends MongoDBResponse {
+  get was() {
+    return this.get('was', BSONType.int, true);
+  }
+}
+
 /** @internal */
 export class ProfilingLevelOperation extends CommandOperation<string> {
+  override SERVER_COMMAND_RESPONSE_TYPE = ProfilingLevelResponse;
   override options: ProfilingLevelOptions;
 
   constructor(db: Db, options: ProfilingLevelOptions) {
@@ -21,14 +28,13 @@ export class ProfilingLevelOperation extends CommandOperation<string> {
     return 'profile' as const;
   }
 
-  override async execute(
-    server: Server,
-    session: ClientSession | undefined,
-    timeoutContext: TimeoutContext
-  ): Promise<string> {
-    const doc = await super.executeCommand(server, session, { profile: -1 }, timeoutContext);
-    if (doc.ok === 1) {
-      const was = doc.was;
+  override buildCommandDocument(_connection: Connection): Document {
+    return { profile: -1 };
+  }
+
+  override handleOk(response: InstanceType<typeof this.SERVER_COMMAND_RESPONSE_TYPE>): string {
+    if (response.ok === 1) {
+      const was = response.was;
       if (was === 0) return 'off';
       if (was === 1) return 'slow_only';
       if (was === 2) return 'all';

package/src/operations/remove_user.ts

@@ -1,7 +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';
 
@@ -10,6 +10,7 @@ export type RemoveUserOptions = CommandOperationOptions;
 
 /** @internal */
 export class RemoveUserOperation extends CommandOperation<boolean> {
+  override SERVER_COMMAND_RESPONSE_TYPE = MongoDBResponse;
   override options: RemoveUserOptions;
   username: string;
 
@@ -23,12 +24,11 @@ export class RemoveUserOperation extends CommandOperation<boolean> {
     return 'dropUser' as const;
   }
 
-  override async execute(
-    server: Server,
-    session: ClientSession | undefined,
-    timeoutContext: TimeoutContext
-  ): Promise<boolean> {
-    await super.executeCommand(server, session, { dropUser: this.username }, timeoutContext);
+  override buildCommandDocument(_connection: Connection): Document {
+    return { dropUser: this.username };
+  }
+
+  override handleOk(_response: InstanceType<typeof this.SERVER_COMMAND_RESPONSE_TYPE>): boolean {
     return true;
   }
 }

package/src/operations/rename.ts

@@ -4,7 +4,7 @@ import { MongoDBResponse } from '../cmap/wire_protocol/responses';
 import { Collection } from '../collection';
 import type { ClientSession } from '../sessions';
 import { MongoDBNamespace } from '../utils';
-import { type CommandOperationOptions, ModernizedCommandOperation } from './command';
+import { CommandOperation, type CommandOperationOptions } from './command';
 import { Aspect, defineAspects } from './operation';
 
 /** @public */
@@ -16,7 +16,7 @@ export interface RenameOptions extends CommandOperationOptions {
 }
 
 /** @internal */
-export class RenameOperation extends ModernizedCommandOperation<Document> {
+export class RenameOperation extends CommandOperation<Document> {
   override SERVER_COMMAND_RESPONSE_TYPE = MongoDBResponse;
   collection: Collection;
   newName: string;

package/src/operations/run_command.ts

@@ -1,13 +1,13 @@
+import { type Abortable } from '..';
 import type { BSONSerializeOptions, Document } from '../bson';
-import { type MongoDBResponseConstructor } from '../cmap/wire_protocol/responses';
-import { type Db } from '../db';
-import { type TODO_NODE_3286 } from '../mongo_types';
+import { type Connection } from '../cmap/connection';
+import { CursorResponse, MongoDBResponse } from '../cmap/wire_protocol/responses';
+import { AbstractOperation } from '../operations/operation';
 import type { ReadPreferenceLike } from '../read_preference';
-import type { Server } from '../sdam/server';
+import type { ServerCommandOptions } from '../sdam/server';
 import type { ClientSession } from '../sessions';
 import { type TimeoutContext } from '../timeout';
-import { MongoDBNamespace } from '../utils';
-import { AbstractOperation } from './operation';
+import { type MongoDBNamespace } from '../utils';
 
 /** @public */
 export type RunCommandOptions = {
@@ -22,86 +22,58 @@ export type RunCommandOptions = {
   timeoutMS?: number;
   /** @internal */
   omitMaxTimeMS?: boolean;
-} & BSONSerializeOptions;
+
+  /**
+   * @internal Hints to `executeOperation` that this operation should not unpin on an ended transaction
+   * This is only used by the driver for transaction commands
+   */
+  bypassPinningCheck?: boolean;
+} & BSONSerializeOptions &
+  Abortable;
 
 /** @internal */
 export class RunCommandOperation<T = Document> extends AbstractOperation<T> {
+  override SERVER_COMMAND_RESPONSE_TYPE = MongoDBResponse;
   command: Document;
-  override options: RunCommandOptions & { responseType?: MongoDBResponseConstructor };
+  override options: RunCommandOptions;
 
-  constructor(
-    parent: Db,
-    command: Document,
-    options: RunCommandOptions & { responseType?: MongoDBResponseConstructor }
-  ) {
+  constructor(namespace: MongoDBNamespace, command: Document, options: RunCommandOptions) {
     super(options);
     this.command = command;
     this.options = options;
-    this.ns = parent.s.namespace.withCollection('$cmd');
+    this.ns = namespace.withCollection('$cmd');
   }
 
   override get commandName() {
     return 'runCommand' as const;
   }
 
-  override async execute(
-    server: Server,
-    session: ClientSession | undefined,
-    timeoutContext: TimeoutContext
-  ): Promise<T> {
-    this.server = server;
-    const res: TODO_NODE_3286 = await server.command(
-      this.ns,
-      this.command,
-      {
-        ...this.options,
-        readPreference: this.readPreference,
-        session,
-        timeoutContext
-      },
-      this.options.responseType
-    );
-
-    return res;
+  override buildCommand(_connection: Connection, _session?: ClientSession): Document {
+    return this.command;
   }
-}
-
-export class RunAdminCommandOperation<T = Document> extends AbstractOperation<T> {
-  command: Document;
-  override options: RunCommandOptions & {
-    noResponse?: boolean;
-    bypassPinningCheck?: boolean;
-  };
 
-  constructor(
-    command: Document,
-    options: RunCommandOptions & {
-      noResponse?: boolean;
-      bypassPinningCheck?: boolean;
-    }
-  ) {
-    super(options);
-    this.command = command;
-    this.options = options;
-    this.ns = new MongoDBNamespace('admin', '$cmd');
+  override buildOptions(timeoutContext: TimeoutContext): ServerCommandOptions {
+    return {
+      ...this.options,
+      session: this.session,
+      timeoutContext,
+      signal: this.options.signal,
+      readPreference: this.options.readPreference
+    };
   }
+}
 
-  override get commandName() {
-    return 'runCommand' as const;
-  }
+/**
+ * @internal
+ *
+ * A specialized subclass of RunCommandOperation for cursor-creating commands.
+ */
+export class RunCursorCommandOperation extends RunCommandOperation {
+  override SERVER_COMMAND_RESPONSE_TYPE = CursorResponse;
 
-  override async execute(
-    server: Server,
-    session: ClientSession | undefined,
-    timeoutContext: TimeoutContext
-  ): Promise<T> {
-    this.server = server;
-    const res: TODO_NODE_3286 = await server.command(this.ns, this.command, {
-      ...this.options,
-      readPreference: this.readPreference,
-      session,
-      timeoutContext
-    });
-    return res;
+  override handleOk(
+    response: InstanceType<typeof this.SERVER_COMMAND_RESPONSE_TYPE>
+  ): CursorResponse {
+    return response;
   }
 }