mongodb 4.5.0 → 4.7.0

package/lib/change_stream.js

@@ -2,7 +2,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ChangeStreamCursor = exports.ChangeStream = void 0;
 const Denque = require("denque");
+const timers_1 = require("timers");
 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");
@@ -23,21 +25,17 @@ const CHANGE_STREAM_OPTIONS = [
     'resumeAfter',
     'startAfter',
     'startAtOperationTime',
-    'fullDocument'
-];
-const CURSOR_OPTIONS = [
-    'batchSize',
-    'maxAwaitTimeMS',
-    'collation',
-    'readPreference',
-    'comment',
-    ...CHANGE_STREAM_OPTIONS
+    'fullDocument',
+    'fullDocumentBeforeChange',
+    'showExpandedEvents'
 ];
 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';
@@ -75,13 +73,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 => {
@@ -101,9 +99,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);
@@ -111,18 +109,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);
                 });
             });
         });
@@ -141,7 +139,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);
             });
@@ -158,45 +156,257 @@ 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 client = this.type === CHANGE_DOMAIN_TYPES.CLUSTER
+            ? this.parent
+            : this.type === CHANGE_DOMAIN_TYPES.DATABASE
+                ? this.parent.s.client
+                : this.type === CHANGE_DOMAIN_TYPES.COLLECTION
+                    ? this.parent.s.db.s.client
+                    : null;
+        if (client == null) {
+            // This should never happen because of the assertion in the constructor
+            throw new error_1.MongoRuntimeError(`Changestream type should only be one of cluster, database, collection. Found ${this.type.toString()}`);
+        }
+        const changeStreamCursor = new ChangeStreamCursor(client, this.namespace, pipeline, options);
+        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) {
+        (0, timers_1.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 error - 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 = {}) {
-        super(topology, namespace, options);
+    constructor(client, namespace, pipeline = [], options = {}) {
+        super(client, namespace, options);
         this.pipeline = pipeline;
         this.options = options;
         this._resumeToken = null;
@@ -216,20 +426,24 @@ class ChangeStreamCursor extends abstract_cursor_1.AbstractCursor {
         return this._resumeToken;
     }
     get resumeOptions() {
-        const result = applyKnownOptions(this.options, CURSOR_OPTIONS);
-        if (this.resumeToken || this.startAtOperationTime) {
-            for (const key of ['resumeAfter', 'startAfter', 'startAtOperationTime']) {
-                Reflect.deleteProperty(result, key);
-            }
-            if (this.resumeToken) {
-                const resumeKey = this.options.startAfter && !this.hasReceived ? 'startAfter' : 'resumeAfter';
-                result[resumeKey] = this.resumeToken;
+        const options = {
+            ...this.options
+        };
+        for (const key of ['resumeAfter', 'startAfter', 'startAtOperationTime']) {
+            delete options[key];
+        }
+        if (this.resumeToken != null) {
+            if (this.options.startAfter && !this.hasReceived) {
+                options.startAfter = this.resumeToken;
             }
-            else if (this.startAtOperationTime && (0, utils_1.maxWireVersion)(this.server) >= 7) {
-                result.startAtOperationTime = this.startAtOperationTime;
+            else {
+                options.resumeAfter = this.resumeToken;
             }
         }
-        return result;
+        else if (this.startAtOperationTime != null && (0, utils_1.maxWireVersion)(this.server) >= 7) {
+            options.startAtOperationTime = this.startAtOperationTime;
+        }
+        return options;
     }
     cacheResumeToken(resumeToken) {
         if (this.bufferedCount() === 0 && this.postBatchResumeToken) {
@@ -240,17 +454,18 @@ 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;
             }
         }
     }
     clone() {
-        return new ChangeStreamCursor(this.topology, this.namespace, this.pipeline, {
+        return new ChangeStreamCursor(this.client, this.namespace, this.pipeline, {
             ...this.cursorOptions
         });
     }
@@ -260,7 +475,7 @@ class ChangeStreamCursor extends abstract_cursor_1.AbstractCursor {
             ...this.options,
             session
         });
-        (0, execute_operation_1.executeOperation)(session, aggregateOperation, (err, response) => {
+        (0, execute_operation_1.executeOperation)(session.client, aggregateOperation, (err, response) => {
             if (err || response == null) {
                 return callback(err);
             }
@@ -271,7 +486,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
@@ -283,7 +498,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);
@@ -291,213 +506,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 = applyKnownOptions(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(source, options) {
-    const result = {};
-    for (const option of options) {
-        if (option in source) {
-            result[option] = source[option];
-        }
-    }
-    return result;
-}
-// 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