mongodb 6.7.0-dev.20240530.sha.f56938f → 6.7.0-dev.20240608.sha.0655c730

package/lib/cursor/abstract_cursor.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.assertUninitialized = exports.AbstractCursor = exports.CURSOR_FLAGS = void 0;
+exports.AbstractCursor = exports.CURSOR_FLAGS = void 0;
 const stream_1 = require("stream");
 const bson_1 = require("../bson");
 const responses_1 = require("../cmap/wire_protocol/responses");
@@ -13,30 +13,6 @@ const read_concern_1 = require("../read_concern");
 const read_preference_1 = require("../read_preference");
 const sessions_1 = require("../sessions");
 const utils_1 = require("../utils");
-/** @internal */
-const kId = Symbol('id');
-/** @internal */
-const kDocuments = Symbol('documents');
-/** @internal */
-const kServer = Symbol('server');
-/** @internal */
-const kNamespace = Symbol('namespace');
-/** @internal */
-const kClient = Symbol('client');
-/** @internal */
-const kSession = Symbol('session');
-/** @internal */
-const kOptions = Symbol('options');
-/** @internal */
-const kTransform = Symbol('transform');
-/** @internal */
-const kInitialized = Symbol('initialized');
-/** @internal */
-const kClosed = Symbol('closed');
-/** @internal */
-const kKilled = Symbol('killed');
-/** @internal */
-const kInit = Symbol('kInit');
 /** @public */
 exports.CURSOR_FLAGS = [
     'tailable',
@@ -51,102 +27,100 @@ class AbstractCursor extends mongo_types_1.TypedEventEmitter {
     /** @internal */
     constructor(client, namespace, options = {}) {
         super();
+        /** @internal */
+        this.hasEmittedClose = false;
         if (!client.s.isMongoClient) {
             throw new error_1.MongoRuntimeError('Cursor must be constructed with MongoClient');
         }
-        this[kClient] = client;
-        this[kNamespace] = namespace;
-        this[kId] = null;
-        this[kDocuments] = new utils_1.List();
-        this[kInitialized] = false;
-        this[kClosed] = false;
-        this[kKilled] = false;
-        this[kOptions] = {
+        this.cursorClient = client;
+        this.cursorNamespace = namespace;
+        this.cursorId = null;
+        this.documents = new utils_1.List();
+        this.initialized = false;
+        this.isClosed = false;
+        this.isKilled = false;
+        this.cursorOptions = {
             readPreference: options.readPreference && options.readPreference instanceof read_preference_1.ReadPreference
                 ? options.readPreference
                 : read_preference_1.ReadPreference.primary,
             ...(0, bson_1.pluckBSONSerializeOptions)(options)
         };
-        this[kOptions].timeoutMS = options.timeoutMS;
+        this.cursorOptions.timeoutMS = options.timeoutMS;
         const readConcern = read_concern_1.ReadConcern.fromOptions(options);
         if (readConcern) {
-            this[kOptions].readConcern = readConcern;
+            this.cursorOptions.readConcern = readConcern;
         }
         if (typeof options.batchSize === 'number') {
-            this[kOptions].batchSize = options.batchSize;
+            this.cursorOptions.batchSize = options.batchSize;
         }
         // we check for undefined specifically here to allow falsy values
         // eslint-disable-next-line no-restricted-syntax
         if (options.comment !== undefined) {
-            this[kOptions].comment = options.comment;
+            this.cursorOptions.comment = options.comment;
         }
         if (typeof options.maxTimeMS === 'number') {
-            this[kOptions].maxTimeMS = options.maxTimeMS;
+            this.cursorOptions.maxTimeMS = options.maxTimeMS;
         }
         if (typeof options.maxAwaitTimeMS === 'number') {
-            this[kOptions].maxAwaitTimeMS = options.maxAwaitTimeMS;
+            this.cursorOptions.maxAwaitTimeMS = options.maxAwaitTimeMS;
         }
         if (options.session instanceof sessions_1.ClientSession) {
-            this[kSession] = options.session;
+            this.cursorSession = options.session;
         }
         else {
-            this[kSession] = this[kClient].startSession({ owner: this, explicit: false });
+            this.cursorSession = this.cursorClient.startSession({ owner: this, explicit: false });
         }
     }
     get id() {
-        return this[kId] ?? undefined;
+        return this.cursorId ?? undefined;
     }
     /** @internal */
     get isDead() {
-        return (this[kId]?.isZero() ?? false) || this[kClosed] || this[kKilled];
+        return (this.cursorId?.isZero() ?? false) || this.isClosed || this.isKilled;
     }
     /** @internal */
     get client() {
-        return this[kClient];
+        return this.cursorClient;
     }
     /** @internal */
     get server() {
-        return this[kServer];
+        return this.selectedServer;
     }
     get namespace() {
-        return this[kNamespace];
+        return this.cursorNamespace;
     }
     get readPreference() {
-        return this[kOptions].readPreference;
+        return this.cursorOptions.readPreference;
     }
     get readConcern() {
-        return this[kOptions].readConcern;
+        return this.cursorOptions.readConcern;
     }
     /** @internal */
     get session() {
-        return this[kSession];
+        return this.cursorSession;
     }
     set session(clientSession) {
-        this[kSession] = clientSession;
-    }
-    /** @internal */
-    get cursorOptions() {
-        return this[kOptions];
+        this.cursorSession = clientSession;
     }
     get closed() {
-        return this[kClosed];
+        return this.isClosed;
     }
     get killed() {
-        return this[kKilled];
+        return this.isKilled;
     }
     get loadBalanced() {
-        return !!this[kClient].topology?.loadBalanced;
+        return !!this.cursorClient.topology?.loadBalanced;
     }
     /** Returns current buffered documents length */
     bufferedCount() {
-        return this[kDocuments].length;
+        return this.documents.length;
     }
     /** Returns current buffered documents */
     readBufferedDocuments(number) {
         const bufferedDocs = [];
-        const documentsToRead = Math.min(number ?? this[kDocuments].length, this[kDocuments].length);
+        const documentsToRead = Math.min(number ?? this.documents.length, this.documents.length);
         for (let count = 0; count < documentsToRead; count++) {
-            const document = this[kDocuments].shift(this[kOptions]);
+            const document = this.documents.shift(this.cursorOptions);
             if (document != null) {
                 bufferedDocs.push(document);
             }
@@ -154,39 +128,32 @@ class AbstractCursor extends mongo_types_1.TypedEventEmitter {
         return bufferedDocs;
     }
     async *[Symbol.asyncIterator]() {
-        if (this.closed) {
+        if (this.isClosed) {
             return;
         }
         try {
             while (true) {
+                if (this.isKilled) {
+                    return;
+                }
+                if (this.isClosed && this.documents.length === 0) {
+                    return;
+                }
+                if (this.cursorId != null && this.isDead && this.documents.length === 0) {
+                    return;
+                }
                 const document = await this.next();
-                // Intentional strict null check, because users can map cursors to falsey values.
-                // We allow mapping to all values except for null.
                 // eslint-disable-next-line no-restricted-syntax
                 if (document === null) {
-                    if (!this.closed) {
-                        const message = 'Cursor returned a `null` document, but the cursor is not exhausted.  Mapping documents to `null` is not supported in the cursor transform.';
-                        try {
-                            await cleanupCursor(this, { needsToEmitClosed: true });
-                        }
-                        catch (error) {
-                            (0, utils_1.squashError)(error);
-                        }
-                        throw new error_1.MongoAPIError(message);
-                    }
-                    break;
+                    return;
                 }
                 yield document;
-                if (this[kId] === bson_1.Long.ZERO) {
-                    // Cursor exhausted
-                    break;
-                }
             }
         }
         finally {
             // Only close the cursor if it has not already been closed. This finally clause handles
             // the case when a user would break out of a for await of loop early.
-            if (!this.closed) {
+            if (!this.isClosed) {
                 try {
                     await this.close();
                 }
@@ -221,29 +188,54 @@ class AbstractCursor extends mongo_types_1.TypedEventEmitter {
         return new ReadableCursorStream(this);
     }
     async hasNext() {
-        if (this[kId] === bson_1.Long.ZERO) {
+        if (this.cursorId === bson_1.Long.ZERO) {
             return false;
         }
-        if (this[kDocuments].length !== 0) {
-            return true;
-        }
-        return await next(this, { blocking: true, transform: false, shift: false });
+        do {
+            if (this.documents.length !== 0) {
+                return true;
+            }
+            await this.fetchBatch();
+        } while (!this.isDead || this.documents.length !== 0);
+        return false;
     }
     /** Get the next available document from the cursor, returns null if no more documents are available. */
     async next() {
-        if (this[kId] === bson_1.Long.ZERO) {
+        if (this.cursorId === bson_1.Long.ZERO) {
             throw new error_1.MongoCursorExhaustedError();
         }
-        return await next(this, { blocking: true, transform: true, shift: true });
+        do {
+            const doc = this.documents.shift();
+            if (doc != null) {
+                if (this.transform != null)
+                    return await this.transformDocument(doc);
+                return doc;
+            }
+            await this.fetchBatch();
+        } while (!this.isDead || this.documents.length !== 0);
+        return null;
     }
     /**
      * Try to get the next available document from the cursor or `null` if an empty batch is returned
      */
     async tryNext() {
-        if (this[kId] === bson_1.Long.ZERO) {
+        if (this.cursorId === bson_1.Long.ZERO) {
             throw new error_1.MongoCursorExhaustedError();
         }
-        return await next(this, { blocking: false, transform: true, shift: true });
+        let doc = this.documents.shift();
+        if (doc != null) {
+            if (this.transform != null)
+                return await this.transformDocument(doc);
+            return doc;
+        }
+        await this.fetchBatch();
+        doc = this.documents.shift();
+        if (doc != null) {
+            if (this.transform != null)
+                return await this.transformDocument(doc);
+            return doc;
+        }
+        return null;
     }
     /**
      * Iterates over all the documents for this cursor using the iterator, callback pattern.
@@ -265,9 +257,7 @@ class AbstractCursor extends mongo_types_1.TypedEventEmitter {
         }
     }
     async close() {
-        const needsToEmitClosed = !this[kClosed];
-        this[kClosed] = true;
-        await cleanupCursor(this, { needsToEmitClosed });
+        await this.cleanup();
     }
     /**
      * Returns an array of documents. The caller is responsible for making sure that there
@@ -289,14 +279,14 @@ class AbstractCursor extends mongo_types_1.TypedEventEmitter {
      * @param value - The flag boolean value.
      */
     addCursorFlag(flag, value) {
-        assertUninitialized(this);
+        this.throwIfInitialized();
         if (!exports.CURSOR_FLAGS.includes(flag)) {
             throw new error_1.MongoInvalidArgumentError(`Flag ${flag} is not one of ${exports.CURSOR_FLAGS}`);
         }
         if (typeof value !== 'boolean') {
             throw new error_1.MongoInvalidArgumentError(`Flag ${flag} must be a boolean value`);
         }
-        this[kOptions][flag] = value;
+        this.cursorOptions[flag] = value;
         return this;
     }
     /**
@@ -342,15 +332,15 @@ class AbstractCursor extends mongo_types_1.TypedEventEmitter {
      * @param transform - The mapping transformation method.
      */
     map(transform) {
-        assertUninitialized(this);
-        const oldTransform = this[kTransform]; // TODO(NODE-3283): Improve transform typing
+        this.throwIfInitialized();
+        const oldTransform = this.transform;
         if (oldTransform) {
-            this[kTransform] = doc => {
+            this.transform = doc => {
                 return transform(oldTransform(doc));
             };
         }
         else {
-            this[kTransform] = transform;
+            this.transform = transform;
         }
         return this;
     }
@@ -360,12 +350,12 @@ class AbstractCursor extends mongo_types_1.TypedEventEmitter {
      * @param readPreference - The new read preference for the cursor.
      */
     withReadPreference(readPreference) {
-        assertUninitialized(this);
+        this.throwIfInitialized();
         if (readPreference instanceof read_preference_1.ReadPreference) {
-            this[kOptions].readPreference = readPreference;
+            this.cursorOptions.readPreference = readPreference;
         }
         else if (typeof readPreference === 'string') {
-            this[kOptions].readPreference = read_preference_1.ReadPreference.fromString(readPreference);
+            this.cursorOptions.readPreference = read_preference_1.ReadPreference.fromString(readPreference);
         }
         else {
             throw new error_1.MongoInvalidArgumentError(`Invalid read preference: ${readPreference}`);
@@ -378,10 +368,10 @@ class AbstractCursor extends mongo_types_1.TypedEventEmitter {
      * @param readPreference - The new read preference for the cursor.
      */
     withReadConcern(readConcern) {
-        assertUninitialized(this);
+        this.throwIfInitialized();
         const resolvedReadConcern = read_concern_1.ReadConcern.fromOptions({ readConcern });
         if (resolvedReadConcern) {
-            this[kOptions].readConcern = resolvedReadConcern;
+            this.cursorOptions.readConcern = resolvedReadConcern;
         }
         return this;
     }
@@ -391,11 +381,11 @@ class AbstractCursor extends mongo_types_1.TypedEventEmitter {
      * @param value - Number of milliseconds to wait before aborting the query.
      */
     maxTimeMS(value) {
-        assertUninitialized(this);
+        this.throwIfInitialized();
         if (typeof value !== 'number') {
             throw new error_1.MongoInvalidArgumentError('Argument for maxTimeMS must be a number');
         }
-        this[kOptions].maxTimeMS = value;
+        this.cursorOptions.maxTimeMS = value;
         return this;
     }
     /**
@@ -404,14 +394,14 @@ class AbstractCursor extends mongo_types_1.TypedEventEmitter {
      * @param value - The number of documents to return per batch. See {@link https://www.mongodb.com/docs/manual/reference/command/find/|find command documentation}.
      */
     batchSize(value) {
-        assertUninitialized(this);
-        if (this[kOptions].tailable) {
+        this.throwIfInitialized();
+        if (this.cursorOptions.tailable) {
             throw new error_1.MongoTailableCursorError('Tailable cursor does not support batchSize');
         }
         if (typeof value !== 'number') {
             throw new error_1.MongoInvalidArgumentError('Operation "batchSize" requires an integer');
         }
-        this[kOptions].batchSize = value;
+        this.cursorOptions.batchSize = value;
         return this;
     }
     /**
@@ -420,15 +410,15 @@ class AbstractCursor extends mongo_types_1.TypedEventEmitter {
      * if the resultant data has already been retrieved by this cursor.
      */
     rewind() {
-        if (!this[kInitialized]) {
+        if (!this.initialized) {
             return;
         }
-        this[kId] = null;
-        this[kDocuments].clear();
-        this[kClosed] = false;
-        this[kKilled] = false;
-        this[kInitialized] = false;
-        const session = this[kSession];
+        this.cursorId = null;
+        this.documents.clear();
+        this.isClosed = false;
+        this.isKilled = false;
+        this.initialized = false;
+        const session = this.cursorSession;
         if (session) {
             // We only want to end this session if we created it, and it hasn't ended yet
             if (session.explicit === false) {
@@ -436,20 +426,25 @@ class AbstractCursor extends mongo_types_1.TypedEventEmitter {
                     // eslint-disable-next-line github/no-then
                     session.endSession().then(undefined, utils_1.squashError);
                 }
-                this[kSession] = this.client.startSession({ owner: this, explicit: false });
+                this.cursorSession = this.cursorClient.startSession({ owner: this, explicit: false });
             }
         }
     }
     /** @internal */
     async getMore(batchSize, useCursorResponse = false) {
-        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-        const getMoreOperation = new get_more_1.GetMoreOperation(this[kNamespace], this[kId], this[kServer], {
-            ...this[kOptions],
-            session: this[kSession],
+        if (this.cursorId == null) {
+            throw new error_1.MongoRuntimeError('Unexpected null cursor id. A cursor creating command should have set this');
+        }
+        if (this.selectedServer == null) {
+            throw new error_1.MongoRuntimeError('Unexpected null selectedServer. A cursor creating command should have set this');
+        }
+        const getMoreOperation = new get_more_1.GetMoreOperation(this.cursorNamespace, this.cursorId, this.selectedServer, {
+            ...this.cursorOptions,
+            session: this.cursorSession,
             batchSize,
             useCursorResponse
         });
-        return await (0, execute_operation_1.executeOperation)(this[kClient], getMoreOperation);
+        return await (0, execute_operation_1.executeOperation)(this.cursorClient, getMoreOperation);
     }
     /**
      * @internal
@@ -458,118 +453,83 @@ class AbstractCursor extends mongo_types_1.TypedEventEmitter {
      * operation.  We cannot refactor to use the abstract _initialize method without
      * a significant refactor.
      */
-    async [kInit]() {
+    async cursorInit() {
         try {
-            const state = await this._initialize(this[kSession]);
+            const state = await this._initialize(this.cursorSession);
             const response = state.response;
-            this[kServer] = state.server;
+            this.selectedServer = state.server;
             if (responses_1.CursorResponse.is(response)) {
-                this[kId] = response.id;
+                this.cursorId = response.id;
                 if (response.ns)
-                    this[kNamespace] = response.ns;
-                this[kDocuments] = response;
+                    this.cursorNamespace = response.ns;
+                this.documents = response;
             }
             else if (response.cursor) {
                 // TODO(NODE-2674): Preserve int64 sent from MongoDB
-                this[kId] =
-                    typeof response.cursor.id === 'number'
-                        ? bson_1.Long.fromNumber(response.cursor.id)
-                        : typeof response.cursor.id === 'bigint'
-                            ? bson_1.Long.fromBigInt(response.cursor.id)
-                            : response.cursor.id;
-                if (response.cursor.ns) {
-                    this[kNamespace] = (0, utils_1.ns)(response.cursor.ns);
-                }
-                this[kDocuments].pushMany(response.cursor.firstBatch);
+                this.cursorId = getCursorId(response);
+                if (response.cursor.ns)
+                    this.cursorNamespace = (0, utils_1.ns)(response.cursor.ns);
+                this.documents.pushMany(response.cursor.firstBatch);
             }
-            // When server responses return without a cursor document, we close this cursor
-            // and return the raw server response. This is often the case for explain commands
-            // for example
-            if (this[kId] == null) {
-                this[kId] = bson_1.Long.ZERO;
+            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 = bson_1.Long.ZERO;
                 // TODO(NODE-3286): ExecutionResult needs to accept a generic parameter
-                this[kDocuments].push(state.response);
+                this.documents.push(state.response);
             }
             // the cursor is now initialized, even if it is dead
-            this[kInitialized] = true;
+            this.initialized = true;
         }
         catch (error) {
             // the cursor is now initialized, even if an error occurred
-            this[kInitialized] = true;
-            await cleanupCursor(this, { error });
+            this.initialized = true;
+            await this.cleanup(error);
             throw error;
         }
         if (this.isDead) {
-            await cleanupCursor(this, undefined);
+            await this.cleanup();
         }
         return;
     }
-}
-/** @event */
-AbstractCursor.CLOSE = 'close';
-exports.AbstractCursor = AbstractCursor;
-async function next(cursor, { blocking, transform, shift }) {
-    if (cursor.closed) {
-        if (!shift)
-            return false;
-        return null;
-    }
-    do {
-        if (cursor[kId] == null) {
-            // All cursors must operate within a session, one must be made implicitly if not explicitly provided
-            await cursor[kInit]();
-        }
-        if (cursor[kDocuments].length !== 0) {
-            if (!shift)
-                return true;
-            const doc = cursor[kDocuments].shift(cursor[kOptions]);
-            if (doc != null && transform && cursor[kTransform]) {
-                try {
-                    return cursor[kTransform](doc);
-                }
-                catch (error) {
-                    try {
-                        await cleanupCursor(cursor, { error, needsToEmitClosed: true });
-                    }
-                    catch (error) {
-                        // `cleanupCursor` should never throw, squash and throw the original error
-                        (0, utils_1.squashError)(error);
-                    }
-                    throw error;
-                }
-            }
-            return doc;
+    /** @internal Attempt to obtain more documents */
+    async fetchBatch() {
+        if (this.isClosed) {
+            return;
         }
-        if (cursor.isDead) {
+        if (this.isDead) {
             // if the cursor is dead, we clean it up
             // cleanupCursor should never throw, but if it does it indicates a bug in the driver
             // and we should surface the error
-            await cleanupCursor(cursor, {});
-            if (!shift)
-                return false;
-            return null;
+            await this.cleanup();
+            return;
+        }
+        if (this.cursorId == null) {
+            await this.cursorInit();
+            // If the cursor died or returned documents, return
+            if (this.documents.length !== 0 || this.isDead)
+                return;
+            // Otherwise, run a getMore
         }
         // otherwise need to call getMore
-        const batchSize = cursor[kOptions].batchSize || 1000;
+        const batchSize = this.cursorOptions.batchSize || 1000;
         try {
-            const response = await cursor.getMore(batchSize);
+            const response = await this.getMore(batchSize);
+            // CursorResponse is disabled in this PR
+            // however the special `emptyGetMore` can be returned from find cursors
             if (responses_1.CursorResponse.is(response)) {
-                cursor[kId] = response.id;
-                cursor[kDocuments] = response;
+                this.cursorId = response.id;
+                this.documents = response;
             }
-            else if (response) {
-                const cursorId = typeof response.cursor.id === 'number'
-                    ? bson_1.Long.fromNumber(response.cursor.id)
-                    : typeof response.cursor.id === 'bigint'
-                        ? bson_1.Long.fromBigInt(response.cursor.id)
-                        : response.cursor.id;
-                cursor[kDocuments].pushMany(response.cursor.nextBatch);
-                cursor[kId] = cursorId;
+            else if (response?.cursor) {
+                const cursorId = getCursorId(response);
+                this.documents.pushMany(response.cursor.nextBatch);
+                this.cursorId = cursorId;
             }
         }
         catch (error) {
             try {
-                await cleanupCursor(cursor, { error, needsToEmitClosed: true });
+                await this.cleanup(error);
             }
             catch (error) {
                 // `cleanupCursor` should never throw, squash and throw the original error
@@ -577,7 +537,7 @@ async function next(cursor, { blocking, transform, shift }) {
             }
             throw error;
         }
-        if (cursor.isDead) {
+        if (this.isDead) {
             // If we successfully received a response from a cursor BUT the cursor indicates that it is exhausted,
             // we intentionally clean up the cursor to release its session back into the pool before the cursor
             // is iterated.  This prevents a cursor that is exhausted on the server from holding
@@ -585,89 +545,91 @@ async function next(cursor, { blocking, transform, shift }) {
             //
             // cleanupCursorAsync should never throw, but if it does it indicates a bug in the driver
             // and we should surface the error
-            await cleanupCursor(cursor, {});
+            await this.cleanup();
         }
-        if (cursor[kDocuments].length === 0 && blocking === false) {
-            if (!shift)
-                return false;
-            return null;
+    }
+    /** @internal */
+    async cleanup(error) {
+        this.isClosed = true;
+        const session = this.cursorSession;
+        try {
+            if (!this.isKilled &&
+                this.cursorId &&
+                !this.cursorId.isZero() &&
+                this.cursorNamespace &&
+                this.selectedServer &&
+                !session.hasEnded) {
+                this.isKilled = true;
+                await (0, execute_operation_1.executeOperation)(this.cursorClient, new kill_cursors_1.KillCursorsOperation(this.cursorId, this.cursorNamespace, this.selectedServer, {
+                    session
+                }));
+            }
         }
-    } while (!cursor.isDead || cursor[kDocuments].length !== 0);
-    if (!shift)
-        return false;
-    return null;
-}
-async function cleanupCursor(cursor, options) {
-    const cursorId = cursor[kId];
-    const cursorNs = cursor[kNamespace];
-    const server = cursor[kServer];
-    const session = cursor[kSession];
-    const error = options?.error;
-    // Cursors only emit closed events once the client-side cursor has been exhausted fully or there
-    // was an error.  Notably, when the server returns a cursor id of 0 and a non-empty batch, we
-    // cleanup the cursor but don't emit a `close` event.
-    const needsToEmitClosed = options?.needsToEmitClosed ?? cursor[kDocuments].length === 0;
-    if (error) {
-        if (cursor.loadBalanced && error instanceof error_1.MongoNetworkError) {
-            return await completeCleanup();
-        }
-    }
-    if (cursorId == null || server == null || cursorId.isZero() || cursorNs == null) {
-        if (needsToEmitClosed) {
-            cursor[kClosed] = true;
-            cursor[kId] = bson_1.Long.ZERO;
-            cursor.emit(AbstractCursor.CLOSE);
+        catch (error) {
+            (0, utils_1.squashError)(error);
         }
-        if (session) {
-            if (session.owner === cursor) {
+        finally {
+            if (session?.owner === this) {
                 await session.endSession({ error });
-                return;
             }
-            if (!session.inTransaction()) {
+            if (!session?.inTransaction()) {
                 (0, sessions_1.maybeClearPinnedConnection)(session, { error });
             }
+            this.emitClose();
         }
-        return;
     }
-    async function completeCleanup() {
-        if (session) {
-            if (session.owner === cursor) {
-                try {
-                    await session.endSession({ error });
-                }
-                finally {
-                    cursor.emit(AbstractCursor.CLOSE);
-                }
-                return;
-            }
-            if (!session.inTransaction()) {
-                (0, sessions_1.maybeClearPinnedConnection)(session, { error });
+    /** @internal */
+    emitClose() {
+        try {
+            if (!this.hasEmittedClose && (this.documents.length === 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');
             }
         }
-        cursor.emit(AbstractCursor.CLOSE);
-        return;
-    }
-    cursor[kKilled] = true;
-    if (session.hasEnded) {
-        return await completeCleanup();
-    }
-    try {
-        await (0, execute_operation_1.executeOperation)(cursor[kClient], new kill_cursors_1.KillCursorsOperation(cursorId, cursorNs, server, { session }));
+        finally {
+            this.hasEmittedClose = true;
+        }
     }
-    catch (error) {
-        (0, utils_1.squashError)(error);
+    /** @internal */
+    async transformDocument(document) {
+        if (this.transform == null)
+            return document;
+        try {
+            const transformedDocument = this.transform(document);
+            // eslint-disable-next-line no-restricted-syntax
+            if (transformedDocument === null) {
+                const TRANSFORM_TO_NULL_ERROR = 'Cursor returned a `null` document, but the cursor is not exhausted.  Mapping documents to `null` is not supported in the cursor transform.';
+                throw new error_1.MongoAPIError(TRANSFORM_TO_NULL_ERROR);
+            }
+            return transformedDocument;
+        }
+        catch (transformError) {
+            try {
+                await this.close();
+            }
+            catch (closeError) {
+                (0, utils_1.squashError)(closeError);
+            }
+            throw transformError;
+        }
     }
-    finally {
-        await completeCleanup();
+    /** @internal */
+    throwIfInitialized() {
+        if (this.initialized)
+            throw new error_1.MongoCursorInUseError();
     }
 }
-/** @internal */
-function assertUninitialized(cursor) {
-    if (cursor[kInitialized]) {
-        throw new error_1.MongoCursorInUseError();
-    }
+/** @event */
+AbstractCursor.CLOSE = 'close';
+exports.AbstractCursor = AbstractCursor;
+/** A temporary helper to box up the many possible type issue of cursor ids */
+function getCursorId(response) {
+    return typeof response.cursor.id === 'number'
+        ? bson_1.Long.fromNumber(response.cursor.id)
+        : typeof response.cursor.id === 'bigint'
+            ? bson_1.Long.fromBigInt(response.cursor.id)
+            : response.cursor.id;
 }
-exports.assertUninitialized = assertUninitialized;
 class ReadableCursorStream extends stream_1.Readable {
     constructor(cursor) {
         super({
@@ -690,8 +652,12 @@ class ReadableCursorStream extends stream_1.Readable {
         this._cursor.close().then(() => callback(error), closeError => callback(closeError));
     }
     _readNext() {
+        if (this._cursor.id === bson_1.Long.ZERO) {
+            this.push(null);
+            return;
+        }
         // eslint-disable-next-line github/no-then
-        next(this._cursor, { blocking: true, transform: true, shift: true }).then(result => {
+        this._cursor.next().then(result => {
             if (result == null) {
                 this.push(null);
             }