mongodb 4.4.1 → 4.6.0

package/lib/change_stream.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ChangeStreamCursor = exports.ChangeStream = void 0;
 const Denque = require("denque");
 const collection_1 = require("./collection");
+const constants_1 = require("./constants");
 const abstract_cursor_1 = require("./cursor/abstract_cursor");
 const db_1 = require("./db");
 const error_1 = require("./error");
@@ -19,13 +20,27 @@ const kCursorStream = Symbol('cursorStream');
 const kClosed = Symbol('closed');
 /** @internal */
 const kMode = Symbol('mode');
-const CHANGE_STREAM_OPTIONS = ['resumeAfter', 'startAfter', 'startAtOperationTime', 'fullDocument'];
-const CURSOR_OPTIONS = ['batchSize', 'maxAwaitTimeMS', 'collation', 'readPreference'].concat(CHANGE_STREAM_OPTIONS);
+const CHANGE_STREAM_OPTIONS = [
+    'resumeAfter',
+    'startAfter',
+    'startAtOperationTime',
+    'fullDocument'
+];
+const CURSOR_OPTIONS = [
+    'batchSize',
+    'maxAwaitTimeMS',
+    'collation',
+    'readPreference',
+    'comment',
+    ...CHANGE_STREAM_OPTIONS
+];
 const CHANGE_DOMAIN_TYPES = {
     COLLECTION: Symbol('Collection'),
     DATABASE: Symbol('Database'),
     CLUSTER: Symbol('Cluster')
 };
+const SELECTION_TIMEOUT = 30000;
+const CHANGE_STREAM_EVENTS = [constants_1.RESUME_TOKEN_CHANGED, constants_1.END, constants_1.CLOSE];
 const NO_RESUME_TOKEN_ERROR = 'A change stream document has been received that lacks a resume token (_id).';
 const NO_CURSOR_ERROR = 'ChangeStream has no cursor';
 const CHANGESTREAM_CLOSED_ERROR = 'ChangeStream is closed';
@@ -63,13 +78,13 @@ class ChangeStream extends mongo_types_1.TypedEventEmitter {
         }
         this[kResumeQueue] = new Denque();
         // Create contained Change Stream cursor
-        this.cursor = createChangeStreamCursor(this, options);
+        this.cursor = this._createChangeStreamCursor(options);
         this[kClosed] = false;
         this[kMode] = false;
         // Listen for any `change` listeners being added to ChangeStream
         this.on('newListener', eventName => {
             if (eventName === 'change' && this.cursor && this.listenerCount('change') === 0) {
-                streamEvents(this, this.cursor);
+                this._streamEvents(this.cursor);
             }
         });
         this.on('removeListener', eventName => {
@@ -89,9 +104,9 @@ class ChangeStream extends mongo_types_1.TypedEventEmitter {
         return (_a = this.cursor) === null || _a === void 0 ? void 0 : _a.resumeToken;
     }
     hasNext(callback) {
-        setIsIterator(this);
+        this._setIsIterator();
         return (0, utils_1.maybePromise)(callback, cb => {
-            getCursor(this, (err, cursor) => {
+            this._getCursor((err, cursor) => {
                 if (err || !cursor)
                     return cb(err); // failed to resume, raise an error
                 cursor.hasNext(cb);
@@ -99,18 +114,18 @@ class ChangeStream extends mongo_types_1.TypedEventEmitter {
         });
     }
     next(callback) {
-        setIsIterator(this);
+        this._setIsIterator();
         return (0, utils_1.maybePromise)(callback, cb => {
-            getCursor(this, (err, cursor) => {
+            this._getCursor((err, cursor) => {
                 if (err || !cursor)
                     return cb(err); // failed to resume, raise an error
                 cursor.next((error, change) => {
                     if (error) {
                         this[kResumeQueue].push(() => this.next(cb));
-                        processError(this, error, cb);
+                        this._processError(error, cb);
                         return;
                     }
-                    processNewChange(this, change, cb);
+                    this._processNewChange(change !== null && change !== void 0 ? change : null, cb);
                 });
             });
         });
@@ -129,7 +144,7 @@ class ChangeStream extends mongo_types_1.TypedEventEmitter {
             }
             const cursor = this.cursor;
             return cursor.close(err => {
-                endStream(this);
+                this._endStream();
                 this.cursor = undefined;
                 return cb(err);
             });
@@ -146,41 +161,243 @@ class ChangeStream extends mongo_types_1.TypedEventEmitter {
         return this.cursor.stream(options);
     }
     tryNext(callback) {
-        setIsIterator(this);
+        this._setIsIterator();
         return (0, utils_1.maybePromise)(callback, cb => {
-            getCursor(this, (err, cursor) => {
+            this._getCursor((err, cursor) => {
                 if (err || !cursor)
                     return cb(err); // failed to resume, raise an error
                 return cursor.tryNext(cb);
             });
         });
     }
+    /** @internal */
+    _setIsEmitter() {
+        if (this[kMode] === 'iterator') {
+            // TODO(NODE-3485): Replace with MongoChangeStreamModeError
+            throw new error_1.MongoAPIError('ChangeStream cannot be used as an EventEmitter after being used as an iterator');
+        }
+        this[kMode] = 'emitter';
+    }
+    /** @internal */
+    _setIsIterator() {
+        if (this[kMode] === 'emitter') {
+            // TODO(NODE-3485): Replace with MongoChangeStreamModeError
+            throw new error_1.MongoAPIError('ChangeStream cannot be used as an iterator after being used as an EventEmitter');
+        }
+        this[kMode] = 'iterator';
+    }
+    /**
+     * Create a new change stream cursor based on self's configuration
+     * @internal
+     */
+    _createChangeStreamCursor(options) {
+        const changeStreamStageOptions = (0, utils_1.filterOptions)(options, CHANGE_STREAM_OPTIONS);
+        if (this.type === CHANGE_DOMAIN_TYPES.CLUSTER) {
+            changeStreamStageOptions.allChangesForCluster = true;
+        }
+        const pipeline = [{ $changeStream: changeStreamStageOptions }, ...this.pipeline];
+        const cursorOptions = (0, utils_1.filterOptions)(options, CURSOR_OPTIONS);
+        const changeStreamCursor = new ChangeStreamCursor((0, utils_1.getTopology)(this.parent), this.namespace, pipeline, cursorOptions);
+        for (const event of CHANGE_STREAM_EVENTS) {
+            changeStreamCursor.on(event, e => this.emit(event, e));
+        }
+        if (this.listenerCount(ChangeStream.CHANGE) > 0) {
+            this._streamEvents(changeStreamCursor);
+        }
+        return changeStreamCursor;
+    }
+    /**
+     * This method performs a basic server selection loop, satisfying the requirements of
+     * ChangeStream resumability until the new SDAM layer can be used.
+     * @internal
+     */
+    _waitForTopologyConnected(topology, options, callback) {
+        setTimeout(() => {
+            if (options && options.start == null) {
+                options.start = (0, utils_1.now)();
+            }
+            const start = options.start || (0, utils_1.now)();
+            const timeout = options.timeout || SELECTION_TIMEOUT;
+            if (topology.isConnected()) {
+                return callback();
+            }
+            if ((0, utils_1.calculateDurationInMs)(start) > timeout) {
+                // TODO(NODE-3497): Replace with MongoNetworkTimeoutError
+                return callback(new error_1.MongoRuntimeError('Timed out waiting for connection'));
+            }
+            this._waitForTopologyConnected(topology, options, callback);
+        }, 500); // this is an arbitrary wait time to allow SDAM to transition
+    }
+    /** @internal */
+    _closeWithError(error, callback) {
+        if (!callback) {
+            this.emit(ChangeStream.ERROR, error);
+        }
+        this.close(() => callback && callback(error));
+    }
+    /** @internal */
+    _streamEvents(cursor) {
+        var _a;
+        this._setIsEmitter();
+        const stream = (_a = this[kCursorStream]) !== null && _a !== void 0 ? _a : cursor.stream();
+        this[kCursorStream] = stream;
+        stream.on('data', change => this._processNewChange(change));
+        stream.on('error', error => this._processError(error));
+    }
+    /** @internal */
+    _endStream() {
+        const cursorStream = this[kCursorStream];
+        if (cursorStream) {
+            ['data', 'close', 'end', 'error'].forEach(event => cursorStream.removeAllListeners(event));
+            cursorStream.destroy();
+        }
+        this[kCursorStream] = undefined;
+    }
+    /** @internal */
+    _processNewChange(change, callback) {
+        var _a;
+        if (this[kClosed]) {
+            // TODO(NODE-3485): Replace with MongoChangeStreamClosedError
+            if (callback)
+                callback(new error_1.MongoAPIError(CHANGESTREAM_CLOSED_ERROR));
+            return;
+        }
+        // a null change means the cursor has been notified, implicitly closing the change stream
+        if (change == null) {
+            // TODO(NODE-3485): Replace with MongoChangeStreamClosedError
+            return this._closeWithError(new error_1.MongoRuntimeError(CHANGESTREAM_CLOSED_ERROR), callback);
+        }
+        if (change && !change._id) {
+            return this._closeWithError(new error_1.MongoChangeStreamError(NO_RESUME_TOKEN_ERROR), callback);
+        }
+        // cache the resume token
+        (_a = this.cursor) === null || _a === void 0 ? void 0 : _a.cacheResumeToken(change._id);
+        // wipe the startAtOperationTime if there was one so that there won't be a conflict
+        // between resumeToken and startAtOperationTime if we need to reconnect the cursor
+        this.options.startAtOperationTime = undefined;
+        // Return the change
+        if (!callback)
+            return this.emit(ChangeStream.CHANGE, change);
+        return callback(undefined, change);
+    }
+    /** @internal */
+    _processError(error, callback) {
+        const cursor = this.cursor;
+        // If the change stream has been closed explicitly, do not process error.
+        if (this[kClosed]) {
+            // TODO(NODE-3485): Replace with MongoChangeStreamClosedError
+            if (callback)
+                callback(new error_1.MongoAPIError(CHANGESTREAM_CLOSED_ERROR));
+            return;
+        }
+        // if the resume succeeds, continue with the new cursor
+        const resumeWithCursor = (newCursor) => {
+            this.cursor = newCursor;
+            this._processResumeQueue();
+        };
+        // otherwise, raise an error and close the change stream
+        const unresumableError = (err) => {
+            if (!callback) {
+                this.emit(ChangeStream.ERROR, err);
+            }
+            this.close(() => this._processResumeQueue(err));
+        };
+        if (cursor && (0, error_1.isResumableError)(error, (0, utils_1.maxWireVersion)(cursor.server))) {
+            this.cursor = undefined;
+            // stop listening to all events from old cursor
+            this._endStream();
+            // close internal cursor, ignore errors
+            cursor.close();
+            const topology = (0, utils_1.getTopology)(this.parent);
+            this._waitForTopologyConnected(topology, { readPreference: cursor.readPreference }, err => {
+                // if the topology can't reconnect, close the stream
+                if (err)
+                    return unresumableError(err);
+                // create a new cursor, preserving the old cursor's options
+                const newCursor = this._createChangeStreamCursor(cursor.resumeOptions);
+                // attempt to continue in emitter mode
+                if (!callback)
+                    return resumeWithCursor(newCursor);
+                // attempt to continue in iterator mode
+                newCursor.hasNext(err => {
+                    // if there's an error immediately after resuming, close the stream
+                    if (err)
+                        return unresumableError(err);
+                    resumeWithCursor(newCursor);
+                });
+            });
+            return;
+        }
+        // if initial error wasn't resumable, raise an error and close the change stream
+        return this._closeWithError(error, callback);
+    }
+    /** @internal */
+    _getCursor(callback) {
+        if (this[kClosed]) {
+            // TODO(NODE-3485): Replace with MongoChangeStreamClosedError
+            callback(new error_1.MongoAPIError(CHANGESTREAM_CLOSED_ERROR));
+            return;
+        }
+        // if a cursor exists and it is open, return it
+        if (this.cursor) {
+            callback(undefined, this.cursor);
+            return;
+        }
+        // no cursor, queue callback until topology reconnects
+        this[kResumeQueue].push(callback);
+    }
+    /**
+     * Drain the resume queue when a new has become available
+     * @internal
+     *
+     * @param err - error getting a new cursor
+     */
+    _processResumeQueue(error) {
+        var _a;
+        while (this[kResumeQueue].length) {
+            const request = this[kResumeQueue].pop();
+            if (!request)
+                break; // Should never occur but TS can't use the length check in the while condition
+            if (!error) {
+                if (this[kClosed]) {
+                    // TODO(NODE-3485): Replace with MongoChangeStreamClosedError
+                    request(new error_1.MongoAPIError(CHANGESTREAM_CLOSED_ERROR));
+                    return;
+                }
+                if (!this.cursor) {
+                    request(new error_1.MongoChangeStreamError(NO_CURSOR_ERROR));
+                    return;
+                }
+            }
+            request(error, (_a = this.cursor) !== null && _a !== void 0 ? _a : undefined);
+        }
+    }
 }
 exports.ChangeStream = ChangeStream;
 /** @event */
-ChangeStream.RESPONSE = 'response';
+ChangeStream.RESPONSE = constants_1.RESPONSE;
 /** @event */
-ChangeStream.MORE = 'more';
+ChangeStream.MORE = constants_1.MORE;
 /** @event */
-ChangeStream.INIT = 'init';
+ChangeStream.INIT = constants_1.INIT;
 /** @event */
-ChangeStream.CLOSE = 'close';
+ChangeStream.CLOSE = constants_1.CLOSE;
 /**
  * Fired for each new matching change in the specified namespace. Attaching a `change`
  * event listener to a Change Stream will switch the stream into flowing mode. Data will
  * then be passed as soon as it is available.
  * @event
  */
-ChangeStream.CHANGE = 'change';
+ChangeStream.CHANGE = constants_1.CHANGE;
 /** @event */
-ChangeStream.END = 'end';
+ChangeStream.END = constants_1.END;
 /** @event */
-ChangeStream.ERROR = 'error';
+ChangeStream.ERROR = constants_1.ERROR;
 /**
  * Emitted each time the change stream stores a new resume token.
  * @event
  */
-ChangeStream.RESUME_TOKEN_CHANGED = 'resumeTokenChanged';
+ChangeStream.RESUME_TOKEN_CHANGED = constants_1.RESUME_TOKEN_CHANGED;
 /** @internal */
 class ChangeStreamCursor extends abstract_cursor_1.AbstractCursor {
     constructor(topology, namespace, pipeline = [], options = {}) {
@@ -204,17 +421,14 @@ class ChangeStreamCursor extends abstract_cursor_1.AbstractCursor {
         return this._resumeToken;
     }
     get resumeOptions() {
-        const result = {};
-        for (const optionName of CURSOR_OPTIONS) {
-            if (Reflect.has(this.options, optionName)) {
-                Reflect.set(result, optionName, Reflect.get(this.options, optionName));
-            }
-        }
+        const result = (0, utils_1.filterOptions)(this.options, CURSOR_OPTIONS);
         if (this.resumeToken || this.startAtOperationTime) {
-            ['resumeAfter', 'startAfter', 'startAtOperationTime'].forEach(key => Reflect.deleteProperty(result, key));
+            for (const key of ['resumeAfter', 'startAfter', 'startAtOperationTime']) {
+                Reflect.deleteProperty(result, key);
+            }
             if (this.resumeToken) {
                 const resumeKey = this.options.startAfter && !this.hasReceived ? 'startAfter' : 'resumeAfter';
-                Reflect.set(result, resumeKey, this.resumeToken);
+                result[resumeKey] = this.resumeToken;
             }
             else if (this.startAtOperationTime && (0, utils_1.maxWireVersion)(this.server) >= 7) {
                 result.startAtOperationTime = this.startAtOperationTime;
@@ -231,11 +445,12 @@ class ChangeStreamCursor extends abstract_cursor_1.AbstractCursor {
         }
         this.hasReceived = true;
     }
-    _processBatch(batchName, response) {
-        const cursor = (response === null || response === void 0 ? void 0 : response.cursor) || {};
+    _processBatch(response) {
+        const cursor = response.cursor;
         if (cursor.postBatchResumeToken) {
-            this.postBatchResumeToken = cursor.postBatchResumeToken;
-            if (cursor[batchName].length === 0) {
+            this.postBatchResumeToken = response.cursor.postBatchResumeToken;
+            const batch = 'firstBatch' in response.cursor ? response.cursor.firstBatch : response.cursor.nextBatch;
+            if (batch.length === 0) {
                 this.resumeToken = cursor.postBatchResumeToken;
             }
         }
@@ -251,7 +466,7 @@ class ChangeStreamCursor extends abstract_cursor_1.AbstractCursor {
             ...this.options,
             session
         });
-        (0, execute_operation_1.executeOperation)(this.topology, aggregateOperation, (err, response) => {
+        (0, execute_operation_1.executeOperation)(session, aggregateOperation, (err, response) => {
             if (err || response == null) {
                 return callback(err);
             }
@@ -262,7 +477,7 @@ class ChangeStreamCursor extends abstract_cursor_1.AbstractCursor {
                 (0, utils_1.maxWireVersion)(server) >= 7) {
                 this.startAtOperationTime = response.operationTime;
             }
-            this._processBatch('firstBatch', response);
+            this._processBatch(response);
             this.emit(ChangeStream.INIT, response);
             this.emit(ChangeStream.RESPONSE);
             // TODO: NODE-2882
@@ -274,7 +489,7 @@ class ChangeStreamCursor extends abstract_cursor_1.AbstractCursor {
             if (err) {
                 return callback(err);
             }
-            this._processBatch('nextBatch', response);
+            this._processBatch(response);
             this.emit(ChangeStream.MORE, response);
             this.emit(ChangeStream.RESPONSE);
             callback(err, response);
@@ -282,213 +497,4 @@ class ChangeStreamCursor extends abstract_cursor_1.AbstractCursor {
     }
 }
 exports.ChangeStreamCursor = ChangeStreamCursor;
-const CHANGE_STREAM_EVENTS = [
-    ChangeStream.RESUME_TOKEN_CHANGED,
-    ChangeStream.END,
-    ChangeStream.CLOSE
-];
-function setIsEmitter(changeStream) {
-    if (changeStream[kMode] === 'iterator') {
-        // TODO(NODE-3485): Replace with MongoChangeStreamModeError
-        throw new error_1.MongoAPIError('ChangeStream cannot be used as an EventEmitter after being used as an iterator');
-    }
-    changeStream[kMode] = 'emitter';
-}
-function setIsIterator(changeStream) {
-    if (changeStream[kMode] === 'emitter') {
-        // TODO(NODE-3485): Replace with MongoChangeStreamModeError
-        throw new error_1.MongoAPIError('ChangeStream cannot be used as an iterator after being used as an EventEmitter');
-    }
-    changeStream[kMode] = 'iterator';
-}
-/**
- * Create a new change stream cursor based on self's configuration
- * @internal
- */
-function createChangeStreamCursor(changeStream, options) {
-    const changeStreamStageOptions = { fullDocument: options.fullDocument || 'default' };
-    applyKnownOptions(changeStreamStageOptions, options, CHANGE_STREAM_OPTIONS);
-    if (changeStream.type === CHANGE_DOMAIN_TYPES.CLUSTER) {
-        changeStreamStageOptions.allChangesForCluster = true;
-    }
-    const pipeline = [{ $changeStream: changeStreamStageOptions }].concat(changeStream.pipeline);
-    const cursorOptions = applyKnownOptions({}, options, CURSOR_OPTIONS);
-    const changeStreamCursor = new ChangeStreamCursor((0, utils_1.getTopology)(changeStream.parent), changeStream.namespace, pipeline, cursorOptions);
-    for (const event of CHANGE_STREAM_EVENTS) {
-        changeStreamCursor.on(event, e => changeStream.emit(event, e));
-    }
-    if (changeStream.listenerCount(ChangeStream.CHANGE) > 0) {
-        streamEvents(changeStream, changeStreamCursor);
-    }
-    return changeStreamCursor;
-}
-function applyKnownOptions(target, source, optionNames) {
-    optionNames.forEach(name => {
-        if (source[name]) {
-            target[name] = source[name];
-        }
-    });
-    return target;
-}
-// This method performs a basic server selection loop, satisfying the requirements of
-// ChangeStream resumability until the new SDAM layer can be used.
-const SELECTION_TIMEOUT = 30000;
-function waitForTopologyConnected(topology, options, callback) {
-    setTimeout(() => {
-        if (options && options.start == null) {
-            options.start = (0, utils_1.now)();
-        }
-        const start = options.start || (0, utils_1.now)();
-        const timeout = options.timeout || SELECTION_TIMEOUT;
-        if (topology.isConnected()) {
-            return callback();
-        }
-        if ((0, utils_1.calculateDurationInMs)(start) > timeout) {
-            // TODO(NODE-3497): Replace with MongoNetworkTimeoutError
-            return callback(new error_1.MongoRuntimeError('Timed out waiting for connection'));
-        }
-        waitForTopologyConnected(topology, options, callback);
-    }, 500); // this is an arbitrary wait time to allow SDAM to transition
-}
-function closeWithError(changeStream, error, callback) {
-    if (!callback) {
-        changeStream.emit(ChangeStream.ERROR, error);
-    }
-    changeStream.close(() => callback && callback(error));
-}
-function streamEvents(changeStream, cursor) {
-    setIsEmitter(changeStream);
-    const stream = changeStream[kCursorStream] || cursor.stream();
-    changeStream[kCursorStream] = stream;
-    stream.on('data', change => processNewChange(changeStream, change));
-    stream.on('error', error => processError(changeStream, error));
-}
-function endStream(changeStream) {
-    const cursorStream = changeStream[kCursorStream];
-    if (cursorStream) {
-        ['data', 'close', 'end', 'error'].forEach(event => cursorStream.removeAllListeners(event));
-        cursorStream.destroy();
-    }
-    changeStream[kCursorStream] = undefined;
-}
-function processNewChange(changeStream, change, callback) {
-    var _a;
-    if (changeStream[kClosed]) {
-        // TODO(NODE-3485): Replace with MongoChangeStreamClosedError
-        if (callback)
-            callback(new error_1.MongoAPIError(CHANGESTREAM_CLOSED_ERROR));
-        return;
-    }
-    // a null change means the cursor has been notified, implicitly closing the change stream
-    if (change == null) {
-        // TODO(NODE-3485): Replace with MongoChangeStreamClosedError
-        return closeWithError(changeStream, new error_1.MongoRuntimeError(CHANGESTREAM_CLOSED_ERROR), callback);
-    }
-    if (change && !change._id) {
-        return closeWithError(changeStream, new error_1.MongoChangeStreamError(NO_RESUME_TOKEN_ERROR), callback);
-    }
-    // cache the resume token
-    (_a = changeStream.cursor) === null || _a === void 0 ? void 0 : _a.cacheResumeToken(change._id);
-    // wipe the startAtOperationTime if there was one so that there won't be a conflict
-    // between resumeToken and startAtOperationTime if we need to reconnect the cursor
-    changeStream.options.startAtOperationTime = undefined;
-    // Return the change
-    if (!callback)
-        return changeStream.emit(ChangeStream.CHANGE, change);
-    return callback(undefined, change);
-}
-function processError(changeStream, error, callback) {
-    const cursor = changeStream.cursor;
-    // If the change stream has been closed explicitly, do not process error.
-    if (changeStream[kClosed]) {
-        // TODO(NODE-3485): Replace with MongoChangeStreamClosedError
-        if (callback)
-            callback(new error_1.MongoAPIError(CHANGESTREAM_CLOSED_ERROR));
-        return;
-    }
-    // if the resume succeeds, continue with the new cursor
-    function resumeWithCursor(newCursor) {
-        changeStream.cursor = newCursor;
-        processResumeQueue(changeStream);
-    }
-    // otherwise, raise an error and close the change stream
-    function unresumableError(err) {
-        if (!callback) {
-            changeStream.emit(ChangeStream.ERROR, err);
-        }
-        changeStream.close(() => processResumeQueue(changeStream, err));
-    }
-    if (cursor && (0, error_1.isResumableError)(error, (0, utils_1.maxWireVersion)(cursor.server))) {
-        changeStream.cursor = undefined;
-        // stop listening to all events from old cursor
-        endStream(changeStream);
-        // close internal cursor, ignore errors
-        cursor.close();
-        const topology = (0, utils_1.getTopology)(changeStream.parent);
-        waitForTopologyConnected(topology, { readPreference: cursor.readPreference }, err => {
-            // if the topology can't reconnect, close the stream
-            if (err)
-                return unresumableError(err);
-            // create a new cursor, preserving the old cursor's options
-            const newCursor = createChangeStreamCursor(changeStream, cursor.resumeOptions);
-            // attempt to continue in emitter mode
-            if (!callback)
-                return resumeWithCursor(newCursor);
-            // attempt to continue in iterator mode
-            newCursor.hasNext(err => {
-                // if there's an error immediately after resuming, close the stream
-                if (err)
-                    return unresumableError(err);
-                resumeWithCursor(newCursor);
-            });
-        });
-        return;
-    }
-    // if initial error wasn't resumable, raise an error and close the change stream
-    return closeWithError(changeStream, error, callback);
-}
-/**
- * Safely provides a cursor across resume attempts
- *
- * @param changeStream - the parent ChangeStream
- */
-function getCursor(changeStream, callback) {
-    if (changeStream[kClosed]) {
-        // TODO(NODE-3485): Replace with MongoChangeStreamClosedError
-        callback(new error_1.MongoAPIError(CHANGESTREAM_CLOSED_ERROR));
-        return;
-    }
-    // if a cursor exists and it is open, return it
-    if (changeStream.cursor) {
-        callback(undefined, changeStream.cursor);
-        return;
-    }
-    // no cursor, queue callback until topology reconnects
-    changeStream[kResumeQueue].push(callback);
-}
-/**
- * Drain the resume queue when a new has become available
- *
- * @param changeStream - the parent ChangeStream
- * @param err - error getting a new cursor
- */
-function processResumeQueue(changeStream, err) {
-    while (changeStream[kResumeQueue].length) {
-        const request = changeStream[kResumeQueue].pop();
-        if (!request)
-            break; // Should never occur but TS can't use the length check in the while condition
-        if (!err) {
-            if (changeStream[kClosed]) {
-                // TODO(NODE-3485): Replace with MongoChangeStreamClosedError
-                request(new error_1.MongoAPIError(CHANGESTREAM_CLOSED_ERROR));
-                return;
-            }
-            if (!changeStream.cursor) {
-                request(new error_1.MongoChangeStreamError(NO_CURSOR_ERROR));
-                return;
-            }
-        }
-        request(err, changeStream.cursor);
-    }
-}
 //# sourceMappingURL=change_stream.js.map