mongodb 6.7.0 → 6.8.0

package/src/cursor/aggregation_cursor.ts

@@ -2,22 +2,17 @@ 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 { AbstractCursor, assertUninitialized } from './abstract_cursor';
+import type { AbstractCursorOptions, InitialCursorResponse } from './abstract_cursor';
+import { AbstractCursor } from './abstract_cursor';
 
 /** @public */
 export interface AggregationCursorOptions extends AbstractCursorOptions, AggregateOptions {}
 
-/** @internal */
-const kPipeline = Symbol('pipeline');
-/** @internal */
-const kOptions = Symbol('options');
-
 /**
  * The **AggregationCursor** class is an internal class that embodies an aggregation cursor on MongoDB
  * allowing for iteration over the results returned from the underlying query. It supports
@@ -26,10 +21,9 @@ const kOptions = Symbol('options');
  * @public
  */
 export class AggregationCursor<TSchema = any> extends AbstractCursor<TSchema> {
+  public readonly pipeline: Document[];
   /** @internal */
-  [kPipeline]: Document[];
-  /** @internal */
-  [kOptions]: AggregateOptions;
+  private aggregateOptions: AggregateOptions;
 
   /** @internal */
   constructor(
@@ -40,18 +34,14 @@ export class AggregationCursor<TSchema = any> extends AbstractCursor<TSchema> {
   ) {
     super(client, namespace, options);
 
-    this[kPipeline] = pipeline;
-    this[kOptions] = options;
-  }
-
-  get pipeline(): Document[] {
-    return this[kPipeline];
+    this.pipeline = pipeline;
+    this.aggregateOptions = options;
   }
 
   clone(): AggregationCursor<TSchema> {
-    const clonedOptions = mergeOptions({}, this[kOptions]);
+    const clonedOptions = mergeOptions({}, this.aggregateOptions);
     delete clonedOptions.session;
-    return new AggregationCursor(this.client, this.namespace, this[kPipeline], {
+    return new AggregationCursor(this.client, this.namespace, this.pipeline, {
       ...clonedOptions
     });
   }
@@ -61,29 +51,30 @@ export class AggregationCursor<TSchema = any> extends AbstractCursor<TSchema> {
   }
 
   /** @internal */
-  async _initialize(session: ClientSession): Promise<ExecutionResult> {
-    const aggregateOperation = new AggregateOperation(this.namespace, this[kPipeline], {
-      ...this[kOptions],
+  async _initialize(session: ClientSession): Promise<InitialCursorResponse> {
+    const aggregateOperation = new AggregateOperation(this.namespace, this.pipeline, {
+      ...this.aggregateOptions,
       ...this.cursorOptions,
       session
     });
 
     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[kPipeline], {
-        ...this[kOptions], // 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
@@ -101,8 +92,8 @@ export class AggregationCursor<TSchema = any> extends AbstractCursor<TSchema> {
   addStage(stage: Document): this;
   addStage<T = Document>(stage: Document): AggregationCursor<T>;
   addStage<T = Document>(stage: Document): AggregationCursor<T> {
-    assertUninitialized(this);
-    this[kPipeline].push(stage);
+    this.throwIfInitialized();
+    this.pipeline.push(stage);
     return this as unknown as AggregationCursor<T>;
   }
 

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,32 +30,17 @@ 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> {
-  _resumeToken: ResumeToken;
-  startAtOperationTime?: OperationTime;
-  hasReceived?: boolean;
-  resumeAfter: ResumeToken;
-  startAfter: ResumeToken;
-  options: ChangeStreamCursorOptions;
-
-  postBatchResumeToken?: ResumeToken;
-  pipeline: Document[];
+  private _resumeToken: ResumeToken;
+  private startAtOperationTime: OperationTime | null;
+  private hasReceived?: boolean;
+  private readonly changeStreamCursorOptions: ChangeStreamCursorOptions;
+  private postBatchResumeToken?: ResumeToken;
+  private readonly pipeline: Document[];
 
   /**
    * @internal
@@ -69,9 +58,9 @@ export class ChangeStreamCursor<
     super(client, namespace, options);
 
     this.pipeline = pipeline;
-    this.options = options;
+    this.changeStreamCursorOptions = options;
     this._resumeToken = null;
-    this.startAtOperationTime = options.startAtOperationTime;
+    this.startAtOperationTime = options.startAtOperationTime ?? null;
 
     if (options.startAfter) {
       this.resumeToken = options.startAfter;
@@ -91,7 +80,7 @@ export class ChangeStreamCursor<
 
   get resumeOptions(): ChangeStreamCursorOptions {
     const options: ChangeStreamCursorOptions = {
-      ...this.options
+      ...this.changeStreamCursorOptions
     };
 
     for (const key of ['resumeAfter', 'startAfter', 'startAtOperationTime'] as const) {
@@ -99,7 +88,7 @@ export class ChangeStreamCursor<
     }
 
     if (this.resumeToken != null) {
-      if (this.options.startAfter && !this.hasReceived) {
+      if (this.changeStreamCursorOptions.startAfter && !this.hasReceived) {
         options.startAfter = this.resumeToken;
       } else {
         options.resumeAfter = this.resumeToken;
@@ -120,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;
       }
     }
   }
@@ -139,25 +126,22 @@ 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.options,
+      ...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);
 
     if (
       this.startAtOperationTime == null &&
-      this.resumeAfter == null &&
-      this.startAfter == null &&
+      this.changeStreamCursorOptions.resumeAfter == null &&
+      this.changeStreamCursorOptions.startAfter == null &&
       this.maxWireVersion >= 7
     ) {
       this.startAtOperationTime = response.operationTime;
@@ -168,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);