mongodb 6.7.0-dev.20240613.sha.c1af6adc → 6.7.0-dev.20240614.sha.3ed6a2ad

package/src/cursor/abstract_cursor.ts

@@ -1,7 +1,7 @@
 import { Readable, Transform } from 'stream';
 
 import { type BSONSerializeOptions, type Document, Long, pluckBSONSerializeOptions } from '../bson';
-import { CursorResponse } from '../cmap/wire_protocol/responses';
+import { type CursorResponse } from '../cmap/wire_protocol/responses';
 import {
   MongoAPIError,
   MongoCursorExhaustedError,
@@ -11,15 +11,33 @@ import {
   MongoTailableCursorError
 } from '../error';
 import type { MongoClient } from '../mongo_client';
-import { type TODO_NODE_3286, TypedEventEmitter } from '../mongo_types';
-import { executeOperation, type ExecutionResult } from '../operations/execute_operation';
+import { TypedEventEmitter } from '../mongo_types';
+import { executeOperation } from '../operations/execute_operation';
 import { GetMoreOperation } from '../operations/get_more';
 import { KillCursorsOperation } from '../operations/kill_cursors';
 import { ReadConcern, type ReadConcernLike } from '../read_concern';
 import { ReadPreference, type ReadPreferenceLike } from '../read_preference';
 import type { Server } from '../sdam/server';
 import { ClientSession, maybeClearPinnedConnection } from '../sessions';
-import { List, type MongoDBNamespace, ns, squashError } from '../utils';
+import { type MongoDBNamespace, squashError } from '../utils';
+
+/**
+ * @internal
+ * TODO(NODE-2882): A cursor's getMore commands must be run on the same server it was started on
+ * and the same session must be used for the lifetime of the cursor. This object serves to get the
+ * server and session (along with the response) out of executeOperation back to the AbstractCursor.
+ *
+ * There may be a better design for communicating these values back to the cursor, currently an operation
+ * MUST store the selected server on itself so it can be read after executeOperation has returned.
+ */
+export interface InitialCursorResponse {
+  /** The server selected for the operation */
+  server: Server;
+  /** The session used for this operation, may be implicitly created */
+  session?: ClientSession;
+  /** The raw server response for the operation */
+  response: CursorResponse;
+}
 
 /** @public */
 export const CURSOR_FLAGS = [
@@ -118,13 +136,7 @@ export abstract class AbstractCursor<
   /** @internal */
   private cursorNamespace: MongoDBNamespace;
   /** @internal */
-  private documents: {
-    length: number;
-    shift(bsonOptions?: any): TSchema | null;
-    clear(): void;
-    pushMany(many: Iterable<TSchema>): void;
-    push(item: TSchema): void;
-  };
+  private documents: CursorResponse | null = null;
   /** @internal */
   private cursorClient: MongoClient;
   /** @internal */
@@ -155,7 +167,6 @@ export abstract class AbstractCursor<
     this.cursorClient = client;
     this.cursorNamespace = namespace;
     this.cursorId = null;
-    this.documents = new List();
     this.initialized = false;
     this.isClosed = false;
     this.isKilled = false;
@@ -252,16 +263,19 @@ export abstract class AbstractCursor<
 
   /** Returns current buffered documents length */
   bufferedCount(): number {
-    return this.documents.length;
+    return this.documents?.length ?? 0;
   }
 
   /** Returns current buffered documents */
   readBufferedDocuments(number?: number): TSchema[] {
     const bufferedDocs: TSchema[] = [];
-    const documentsToRead = Math.min(number ?? this.documents.length, this.documents.length);
+    const documentsToRead = Math.min(
+      number ?? this.documents?.length ?? 0,
+      this.documents?.length ?? 0
+    );
 
     for (let count = 0; count < documentsToRead; count++) {
-      const document = this.documents.shift(this.cursorOptions);
+      const document = this.documents?.shift(this.cursorOptions);
       if (document != null) {
         bufferedDocs.push(document);
       }
@@ -269,7 +283,6 @@ export abstract class AbstractCursor<
 
     return bufferedDocs;
   }
-
   async *[Symbol.asyncIterator](): AsyncGenerator<TSchema, void, void> {
     if (this.isClosed) {
       return;
@@ -281,11 +294,11 @@ export abstract class AbstractCursor<
           return;
         }
 
-        if (this.isClosed && this.documents.length === 0) {
+        if (this.closed && (this.documents?.length ?? 0) === 0) {
           return;
         }
 
-        if (this.cursorId != null && this.isDead && this.documents.length === 0) {
+        if (this.cursorId != null && this.isDead && (this.documents?.length ?? 0) === 0) {
           return;
         }
 
@@ -347,11 +360,11 @@ export abstract class AbstractCursor<
     }
 
     do {
-      if (this.documents.length !== 0) {
+      if ((this.documents?.length ?? 0) !== 0) {
         return true;
       }
       await this.fetchBatch();
-    } while (!this.isDead || this.documents.length !== 0);
+    } while (!this.isDead || (this.documents?.length ?? 0) !== 0);
 
     return false;
   }
@@ -363,13 +376,13 @@ export abstract class AbstractCursor<
     }
 
     do {
-      const doc = this.documents.shift();
+      const doc = this.documents?.shift(this.cursorOptions);
       if (doc != null) {
         if (this.transform != null) return await this.transformDocument(doc);
         return doc;
       }
       await this.fetchBatch();
-    } while (!this.isDead || this.documents.length !== 0);
+    } while (!this.isDead || (this.documents?.length ?? 0) !== 0);
 
     return null;
   }
@@ -382,7 +395,7 @@ export abstract class AbstractCursor<
       throw new MongoCursorExhaustedError();
     }
 
-    let doc = this.documents.shift();
+    let doc = this.documents?.shift(this.cursorOptions);
     if (doc != null) {
       if (this.transform != null) return await this.transformDocument(doc);
       return doc;
@@ -390,7 +403,7 @@ export abstract class AbstractCursor<
 
     await this.fetchBatch();
 
-    doc = this.documents.shift();
+    doc = this.documents?.shift(this.cursorOptions);
     if (doc != null) {
       if (this.transform != null) return await this.transformDocument(doc);
       return doc;
@@ -591,7 +604,7 @@ export abstract class AbstractCursor<
     }
 
     this.cursorId = null;
-    this.documents.clear();
+    this.documents?.clear();
     this.isClosed = false;
     this.isKilled = false;
     this.initialized = false;
@@ -615,10 +628,12 @@ export abstract class AbstractCursor<
   abstract clone(): AbstractCursor<TSchema>;
 
   /** @internal */
-  protected abstract _initialize(session: ClientSession | undefined): Promise<ExecutionResult>;
+  protected abstract _initialize(
+    session: ClientSession | undefined
+  ): Promise<InitialCursorResponse>;
 
   /** @internal */
-  async getMore(batchSize: number, useCursorResponse = false): Promise<Document | null> {
+  async getMore(batchSize: number): Promise<CursorResponse> {
     if (this.cursorId == null) {
       throw new MongoRuntimeError(
         'Unexpected null cursor id. A cursor creating command should have set this'
@@ -636,8 +651,7 @@ export abstract class AbstractCursor<
       {
         ...this.cursorOptions,
         session: this.cursorSession,
-        batchSize,
-        useCursorResponse
+        batchSize
       }
     );
 
@@ -656,27 +670,10 @@ export abstract class AbstractCursor<
       const state = await this._initialize(this.cursorSession);
       const response = state.response;
       this.selectedServer = state.server;
-      if (CursorResponse.is(response)) {
-        this.cursorId = response.id;
-        if (response.ns) this.cursorNamespace = response.ns;
-        this.documents = response;
-      } else if (response.cursor) {
-        // TODO(NODE-2674): Preserve int64 sent from MongoDB
-        this.cursorId = getCursorId(response);
-        if (response.cursor.ns) this.cursorNamespace = ns(response.cursor.ns);
-        this.documents.pushMany(response.cursor.firstBatch);
-      }
-
-      if (this.cursorId == null) {
-        // When server responses return without a cursor document, we close this cursor
-        // and return the raw server response. This is the case for explain commands
-        this.cursorId = Long.ZERO;
-        // TODO(NODE-3286): ExecutionResult needs to accept a generic parameter
-        this.documents.push(state.response as TODO_NODE_3286);
-      }
-
-      // the cursor is now initialized, even if it is dead
-      this.initialized = true;
+      this.cursorId = response.id;
+      this.cursorNamespace = response.ns ?? this.namespace;
+      this.documents = response;
+      this.initialized = true; // the cursor is now initialized, even if it is dead
     } catch (error) {
       // the cursor is now initialized, even if an error occurred
       this.initialized = true;
@@ -708,7 +705,7 @@ export abstract class AbstractCursor<
     if (this.cursorId == null) {
       await this.cursorInit();
       // If the cursor died or returned documents, return
-      if (this.documents.length !== 0 || this.isDead) return;
+      if ((this.documents?.length ?? 0) !== 0 || this.isDead) return;
       // Otherwise, run a getMore
     }
 
@@ -717,16 +714,8 @@ export abstract class AbstractCursor<
 
     try {
       const response = await this.getMore(batchSize);
-      // CursorResponse is disabled in this PR
-      // however the special `emptyGetMore` can be returned from find cursors
-      if (CursorResponse.is(response)) {
-        this.cursorId = response.id;
-        this.documents = response;
-      } else if (response?.cursor) {
-        const cursorId = getCursorId(response);
-        this.documents.pushMany(response.cursor.nextBatch);
-        this.cursorId = cursorId;
-      }
+      this.cursorId = response.id;
+      this.documents = response;
     } catch (error) {
       try {
         await this.cleanup(error);
@@ -789,7 +778,7 @@ export abstract class AbstractCursor<
   /** @internal */
   private emitClose() {
     try {
-      if (!this.hasEmittedClose && (this.documents.length === 0 || this.isClosed)) {
+      if (!this.hasEmittedClose && ((this.documents?.length ?? 0) === 0 || this.isClosed)) {
         // @ts-expect-error: CursorEvents is generic so Parameters<CursorEvents["close"]> may not be assignable to `[]`. Not sure how to require extenders do not add parameters.
         this.emit('close');
       }
@@ -827,15 +816,6 @@ export abstract class AbstractCursor<
   }
 }
 
-/** A temporary helper to box up the many possible type issue of cursor ids */
-function getCursorId(response: Document) {
-  return typeof response.cursor.id === 'number'
-    ? Long.fromNumber(response.cursor.id)
-    : typeof response.cursor.id === 'bigint'
-    ? Long.fromBigInt(response.cursor.id)
-    : response.cursor.id;
-}
-
 class ReadableCursorStream extends Readable {
   private _cursor: AbstractCursor;
   private _readInProgress = false;

package/src/cursor/aggregation_cursor.ts

@@ -2,12 +2,12 @@ import type { Document } from '../bson';
 import type { ExplainVerbosityLike } from '../explain';
 import type { MongoClient } from '../mongo_client';
 import { AggregateOperation, type AggregateOptions } from '../operations/aggregate';
-import { executeOperation, type ExecutionResult } from '../operations/execute_operation';
+import { executeOperation } from '../operations/execute_operation';
 import type { ClientSession } from '../sessions';
 import type { Sort } from '../sort';
 import type { MongoDBNamespace } from '../utils';
 import { mergeOptions } from '../utils';
-import type { AbstractCursorOptions } from './abstract_cursor';
+import type { AbstractCursorOptions, InitialCursorResponse } from './abstract_cursor';
 import { AbstractCursor } from './abstract_cursor';
 
 /** @public */
@@ -51,7 +51,7 @@ export class AggregationCursor<TSchema = any> extends AbstractCursor<TSchema> {
   }
 
   /** @internal */
-  async _initialize(session: ClientSession): Promise<ExecutionResult> {
+  async _initialize(session: ClientSession): Promise<InitialCursorResponse> {
     const aggregateOperation = new AggregateOperation(this.namespace, this.pipeline, {
       ...this.aggregateOptions,
       ...this.cursorOptions,
@@ -60,20 +60,21 @@ export class AggregationCursor<TSchema = any> extends AbstractCursor<TSchema> {
 
     const response = await executeOperation(this.client, aggregateOperation);
 
-    // TODO: NODE-2882
     return { server: aggregateOperation.server, session, response };
   }
 
   /** Execute the explain for the cursor */
   async explain(verbosity?: ExplainVerbosityLike): Promise<Document> {
-    return await executeOperation(
-      this.client,
-      new AggregateOperation(this.namespace, this.pipeline, {
-        ...this.aggregateOptions, // NOTE: order matters here, we may need to refine this
-        ...this.cursorOptions,
-        explain: verbosity ?? true
-      })
-    );
+    return (
+      await executeOperation(
+        this.client,
+        new AggregateOperation(this.namespace, this.pipeline, {
+          ...this.aggregateOptions, // NOTE: order matters here, we may need to refine this
+          ...this.cursorOptions,
+          explain: verbosity ?? true
+        })
+      )
+    ).shift(this.aggregateOptions);
   }
 
   /** Add a stage to the aggregation pipeline

package/src/cursor/change_stream_cursor.ts

@@ -1,4 +1,4 @@
-import type { Document, Long, Timestamp } from '../bson';
+import type { Document } from '../bson';
 import {
   ChangeStream,
   type ChangeStreamDocument,
@@ -6,15 +6,19 @@ import {
   type OperationTime,
   type ResumeToken
 } from '../change_stream';
+import { type CursorResponse } from '../cmap/wire_protocol/responses';
 import { INIT, RESPONSE } from '../constants';
 import type { MongoClient } from '../mongo_client';
-import type { TODO_NODE_3286 } from '../mongo_types';
 import { AggregateOperation } from '../operations/aggregate';
 import type { CollationOptions } from '../operations/command';
-import { executeOperation, type ExecutionResult } from '../operations/execute_operation';
+import { executeOperation } from '../operations/execute_operation';
 import type { ClientSession } from '../sessions';
 import { maxWireVersion, type MongoDBNamespace } from '../utils';
-import { AbstractCursor, type AbstractCursorOptions } from './abstract_cursor';
+import {
+  AbstractCursor,
+  type AbstractCursorOptions,
+  type InitialCursorResponse
+} from './abstract_cursor';
 
 /** @internal */
 export interface ChangeStreamCursorOptions extends AbstractCursorOptions {
@@ -26,25 +30,13 @@ export interface ChangeStreamCursorOptions extends AbstractCursorOptions {
   fullDocument?: string;
 }
 
-/** @internal */
-export type ChangeStreamAggregateRawResult<TChange> = {
-  $clusterTime: { clusterTime: Timestamp };
-  cursor: {
-    postBatchResumeToken: ResumeToken;
-    ns: string;
-    id: number | Long;
-  } & ({ firstBatch: TChange[] } | { nextBatch: TChange[] });
-  ok: 1;
-  operationTime: Timestamp;
-};
-
 /** @internal */
 export class ChangeStreamCursor<
   TSchema extends Document = Document,
   TChange extends Document = ChangeStreamDocument<TSchema>
 > extends AbstractCursor<TChange, ChangeStreamEvents> {
   private _resumeToken: ResumeToken;
-  private startAtOperationTime?: OperationTime;
+  private startAtOperationTime: OperationTime | null;
   private hasReceived?: boolean;
   private readonly changeStreamCursorOptions: ChangeStreamCursorOptions;
   private postBatchResumeToken?: ResumeToken;
@@ -68,7 +60,7 @@ export class ChangeStreamCursor<
     this.pipeline = pipeline;
     this.changeStreamCursorOptions = options;
     this._resumeToken = null;
-    this.startAtOperationTime = options.startAtOperationTime;
+    this.startAtOperationTime = options.startAtOperationTime ?? null;
 
     if (options.startAfter) {
       this.resumeToken = options.startAfter;
@@ -117,15 +109,13 @@ export class ChangeStreamCursor<
     this.hasReceived = true;
   }
 
-  _processBatch(response: ChangeStreamAggregateRawResult<TChange>): void {
-    const cursor = response.cursor;
-    if (cursor.postBatchResumeToken) {
-      this.postBatchResumeToken = response.cursor.postBatchResumeToken;
+  _processBatch(response: CursorResponse): void {
+    const { postBatchResumeToken } = response;
+    if (postBatchResumeToken) {
+      this.postBatchResumeToken = postBatchResumeToken;
 
-      const batch =
-        'firstBatch' in response.cursor ? response.cursor.firstBatch : response.cursor.nextBatch;
-      if (batch.length === 0) {
-        this.resumeToken = cursor.postBatchResumeToken;
+      if (response.batchSize === 0) {
+        this.resumeToken = postBatchResumeToken;
       }
     }
   }
@@ -136,17 +126,14 @@ export class ChangeStreamCursor<
     });
   }
 
-  async _initialize(session: ClientSession): Promise<ExecutionResult> {
+  async _initialize(session: ClientSession): Promise<InitialCursorResponse> {
     const aggregateOperation = new AggregateOperation(this.namespace, this.pipeline, {
       ...this.cursorOptions,
       ...this.changeStreamCursorOptions,
       session
     });
 
-    const response = await executeOperation<
-      TODO_NODE_3286,
-      ChangeStreamAggregateRawResult<TChange>
-    >(session.client, aggregateOperation);
+    const response = await executeOperation(session.client, aggregateOperation);
 
     const server = aggregateOperation.server;
     this.maxWireVersion = maxWireVersion(server);
@@ -165,15 +152,14 @@ export class ChangeStreamCursor<
     this.emit(INIT, response);
     this.emit(RESPONSE);
 
-    // TODO: NODE-2882
     return { server, session, response };
   }
 
-  override async getMore(batchSize: number): Promise<Document | null> {
+  override async getMore(batchSize: number): Promise<CursorResponse> {
     const response = await super.getMore(batchSize);
 
     this.maxWireVersion = maxWireVersion(this.server);
-    this._processBatch(response as ChangeStreamAggregateRawResult<TChange>);
+    this._processBatch(response);
 
     this.emit(ChangeStream.MORE, response);
     this.emit(ChangeStream.RESPONSE);

package/src/cursor/find_cursor.ts

@@ -5,13 +5,13 @@ import { type ExplainVerbosityLike } from '../explain';
 import type { MongoClient } from '../mongo_client';
 import type { CollationOptions } from '../operations/command';
 import { CountOperation, type CountOptions } from '../operations/count';
-import { executeOperation, type ExecutionResult } from '../operations/execute_operation';
+import { executeOperation } from '../operations/execute_operation';
 import { FindOperation, type FindOptions } from '../operations/find';
 import type { Hint } from '../operations/operation';
 import type { ClientSession } from '../sessions';
 import { formatSort, type Sort, type SortDirection } from '../sort';
 import { emitWarningOnce, mergeOptions, type MongoDBNamespace, squashError } from '../utils';
-import { AbstractCursor } from './abstract_cursor';
+import { AbstractCursor, type InitialCursorResponse } from './abstract_cursor';
 
 /** @public Flags allowed for cursor */
 export const FLAGS = [
@@ -62,7 +62,7 @@ export class FindCursor<TSchema = any> extends AbstractCursor<TSchema> {
   }
 
   /** @internal */
-  async _initialize(session: ClientSession): Promise<ExecutionResult> {
+  async _initialize(session: ClientSession): Promise<InitialCursorResponse> {
     const findOperation = new FindOperation(this.namespace, this.cursorFilter, {
       ...this.findOptions, // NOTE: order matters here, we may need to refine this
       ...this.cursorOptions,
@@ -72,19 +72,13 @@ export class FindCursor<TSchema = any> extends AbstractCursor<TSchema> {
     const response = await executeOperation(this.client, findOperation);
 
     // the response is not a cursor when `explain` is enabled
-    if (CursorResponse.is(response)) {
-      this.numReturned = response.batchSize;
-    } else {
-      // Can be an explain response, hence the ?. on everything
-      this.numReturned = this.numReturned + (response?.cursor?.firstBatch?.length ?? 0);
-    }
+    this.numReturned = response.batchSize;
 
-    // TODO: NODE-2882
     return { server: findOperation.server, session, response };
   }
 
   /** @internal */
-  override async getMore(batchSize: number): Promise<Document | null> {
+  override async getMore(batchSize: number): Promise<CursorResponse> {
     const numReturned = this.numReturned;
     if (numReturned) {
       // TODO(DRIVERS-1448): Remove logic to enforce `limit` in the driver
@@ -110,13 +104,9 @@ export class FindCursor<TSchema = any> extends AbstractCursor<TSchema> {
       }
     }
 
-    const response = await super.getMore(batchSize, false);
+    const response = await super.getMore(batchSize);
     // TODO: wrap this in some logic to prevent it from happening if we don't need this support
-    if (CursorResponse.is(response)) {
-      this.numReturned = this.numReturned + response.batchSize;
-    } else {
-      this.numReturned = this.numReturned + (response?.cursor?.nextBatch?.length ?? 0);
-    }
+    this.numReturned = this.numReturned + response.batchSize;
 
     return response;
   }
@@ -144,14 +134,16 @@ export class FindCursor<TSchema = any> extends AbstractCursor<TSchema> {
 
   /** Execute the explain for the cursor */
   async explain(verbosity?: ExplainVerbosityLike): Promise<Document> {
-    return await executeOperation(
-      this.client,
-      new FindOperation(this.namespace, this.cursorFilter, {
-        ...this.findOptions, // NOTE: order matters here, we may need to refine this
-        ...this.cursorOptions,
-        explain: verbosity ?? true
-      })
-    );
+    return (
+      await executeOperation(
+        this.client,
+        new FindOperation(this.namespace, this.cursorFilter, {
+          ...this.findOptions, // NOTE: order matters here, we may need to refine this
+          ...this.cursorOptions,
+          explain: verbosity ?? true
+        })
+      )
+    ).shift(this.findOptions);
   }
 
   /** Set the cursor query */

package/src/cursor/list_collections_cursor.ts

@@ -1,13 +1,13 @@
 import type { Document } from '../bson';
 import type { Db } from '../db';
-import { executeOperation, type ExecutionResult } from '../operations/execute_operation';
+import { executeOperation } from '../operations/execute_operation';
 import {
   type CollectionInfo,
   ListCollectionsOperation,
   type ListCollectionsOptions
 } from '../operations/list_collections';
 import type { ClientSession } from '../sessions';
-import { AbstractCursor } from './abstract_cursor';
+import { AbstractCursor, type InitialCursorResponse } from './abstract_cursor';
 
 /** @public */
 export class ListCollectionsCursor<
@@ -34,7 +34,7 @@ export class ListCollectionsCursor<
   }
 
   /** @internal */
-  async _initialize(session: ClientSession | undefined): Promise<ExecutionResult> {
+  async _initialize(session: ClientSession | undefined): Promise<InitialCursorResponse> {
     const operation = new ListCollectionsOperation(this.parent, this.filter, {
       ...this.cursorOptions,
       ...this.options,
@@ -43,7 +43,6 @@ export class ListCollectionsCursor<
 
     const response = await executeOperation(this.parent.client, operation);
 
-    // TODO: NODE-2882
     return { server: operation.server, session, response };
   }
 }

package/src/cursor/list_indexes_cursor.ts

@@ -1,8 +1,8 @@
 import type { Collection } from '../collection';
-import { executeOperation, type ExecutionResult } from '../operations/execute_operation';
+import { executeOperation } from '../operations/execute_operation';
 import { ListIndexesOperation, type ListIndexesOptions } from '../operations/indexes';
 import type { ClientSession } from '../sessions';
-import { AbstractCursor } from './abstract_cursor';
+import { AbstractCursor, type InitialCursorResponse } from './abstract_cursor';
 
 /** @public */
 export class ListIndexesCursor extends AbstractCursor {
@@ -23,7 +23,7 @@ export class ListIndexesCursor extends AbstractCursor {
   }
 
   /** @internal */
-  async _initialize(session: ClientSession | undefined): Promise<ExecutionResult> {
+  async _initialize(session: ClientSession | undefined): Promise<InitialCursorResponse> {
     const operation = new ListIndexesOperation(this.parent, {
       ...this.cursorOptions,
       ...this.options,
@@ -32,7 +32,6 @@ export class ListIndexesCursor extends AbstractCursor {
 
     const response = await executeOperation(this.parent.client, operation);
 
-    // TODO: NODE-2882
     return { server: operation.server, session, response };
   }
 }

package/src/cursor/run_command_cursor.ts

@@ -1,14 +1,15 @@
-import type { BSONSerializeOptions, Document, Long } from '../bson';
+import type { BSONSerializeOptions, Document } from '../bson';
+import { CursorResponse } from '../cmap/wire_protocol/responses';
 import type { Db } from '../db';
-import { MongoAPIError, MongoUnexpectedServerResponseError } from '../error';
-import { executeOperation, type ExecutionResult } from '../operations/execute_operation';
+import { MongoAPIError } from '../error';
+import { executeOperation } from '../operations/execute_operation';
 import { GetMoreOperation } from '../operations/get_more';
 import { RunCommandOperation } from '../operations/run_command';
 import type { ReadConcernLike } from '../read_concern';
 import type { ReadPreferenceLike } from '../read_preference';
 import type { ClientSession } from '../sessions';
 import { ns } from '../utils';
-import { AbstractCursor } from './abstract_cursor';
+import { AbstractCursor, type InitialCursorResponse } from './abstract_cursor';
 
 /** @public */
 export type RunCursorCommandOptions = {
@@ -16,12 +17,6 @@ export type RunCursorCommandOptions = {
   session?: ClientSession;
 } & BSONSerializeOptions;
 
-/** @internal */
-type RunCursorCommandResponse = {
-  cursor: { id: bigint | Long | number; ns: string; firstBatch: Document[] };
-  ok: 1;
-};
-
 /** @public */
 export class RunCommandCursor extends AbstractCursor {
   public readonly command: Readonly<Record<string, any>>;
@@ -102,16 +97,16 @@ export class RunCommandCursor extends AbstractCursor {
   }
 
   /** @internal */
-  protected async _initialize(session: ClientSession): Promise<ExecutionResult> {
-    const operation = new RunCommandOperation<RunCursorCommandResponse>(this.db, this.command, {
+  protected async _initialize(session: ClientSession): Promise<InitialCursorResponse> {
+    const operation = new RunCommandOperation<CursorResponse>(this.db, this.command, {
       ...this.cursorOptions,
       session: session,
-      readPreference: this.cursorOptions.readPreference
+      readPreference: this.cursorOptions.readPreference,
+      responseType: CursorResponse
     });
+
     const response = await executeOperation(this.client, operation);
-    if (response.cursor == null) {
-      throw new MongoUnexpectedServerResponseError('Expected server to respond with cursor');
-    }
+
     return {
       server: operation.server,
       session,
@@ -120,13 +115,12 @@ export class RunCommandCursor extends AbstractCursor {
   }
 
   /** @internal */
-  override async getMore(_batchSize: number): Promise<Document> {
+  override async getMore(_batchSize: number): Promise<CursorResponse> {
     // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
     const getMoreOperation = new GetMoreOperation(this.namespace, this.id!, this.server!, {
       ...this.cursorOptions,
       session: this.session,
-      ...this.getMoreOptions,
-      useCursorResponse: false
+      ...this.getMoreOptions
     });
 
     return await executeOperation(this.client, getMoreOperation);