mongodb-livedata-server 0.1.3 → 0.1.4

package/dist/meteor/mongo/live_connection.js

@@ -1,264 +1,264 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.LiveMongoConnection = void 0;
-const hook_1 = require("../callback-hook/hook");
-const mongodb_1 = require("mongodb");
-const live_cursor_1 = require("./live_cursor");
-const ejson_1 = require("../ejson/ejson");
-const synchronous_cursor_1 = require("./synchronous-cursor");
-const oplog_tailing_1 = require("./oplog_tailing");
-const doc_fetcher_1 = require("./doc_fetcher");
-const observe_multiplexer_1 = require("./observe_multiplexer");
-const polling_observe_driver_1 = require("./polling_observe_driver");
-const oplog_observe_driver_1 = require("./oplog-observe-driver");
-const minimongo_matcher_1 = require("./minimongo_matcher");
-const minimongo_sorter_1 = __importDefault(require("./minimongo_sorter"));
-class LiveMongoConnection {
-    constructor(url, options) {
-        this._oplogHandle = null;
-        this._docFetcher = null;
-        this._observeMultiplexers = {};
-        this._onFailoverHook = new hook_1.Hook();
-        options = options || {};
-        var mongoOptions = {
-            ignoreUndefined: true,
-            maxPoolSize: undefined
-        };
-        // Internally the oplog connections specify their own maxPoolSize
-        // which we don't want to overwrite with any user defined value
-        if (options.hasOwnProperty("maxPoolSize")) {
-            // If we just set this for "server", replSet will override it. If we just
-            // set it for replSet, it will be ignored if we're not using a replSet.
-            mongoOptions.maxPoolSize = options.maxPoolSize;
-        }
-        this.client = new mongodb_1.MongoClient(url, mongoOptions);
-        this.db = this.client.db();
-        this.client.on('serverDescriptionChanged', event => {
-            // When the connection is no longer against the primary node, execute all
-            // failover hooks. This is important for the driver as it has to re-pool the
-            // query when it happens.
-            if (event.previousDescription.type !== 'RSPrimary' &&
-                event.newDescription.type === 'RSPrimary') {
-                this._onFailoverHook.each(callback => {
-                    callback();
-                    return true;
-                });
-            }
-        });
-        if (options.oplogUrl) {
-            this._oplogHandle = new oplog_tailing_1.OplogHandle(options.oplogUrl, this.db.databaseName);
-            this._docFetcher = new doc_fetcher_1.DocFetcher(this.db);
-        }
-    }
-    close() {
-        var self = this;
-        if (!self.db)
-            throw Error("close called before Connection created?");
-        // XXX probably untested
-        var oplogHandle = self._oplogHandle;
-        self._oplogHandle = null;
-        if (oplogHandle)
-            oplogHandle.stop();
-        // Use Future.wrap so that errors get thrown. This happens to
-        // work even outside a fiber since the 'close' method is not
-        // actually asynchronous.
-        self.client.close(true);
-    }
-    // Tails the cursor described by cursorDescription, most likely on the
-    // oplog. Calls docCallback with each document found. Ignores errors and just
-    // restarts the tail on error.
-    //
-    // If timeoutMS is set, then if we don't get a new document every timeoutMS,
-    // kill and restart the cursor. This is primarily a workaround for #8598.
-    tail(cursorDescription, docCallback, timeoutMS) {
-        if (!cursorDescription.options.tailable)
-            throw new Error("Can only tail a tailable cursor");
-        var cursor = (0, synchronous_cursor_1._createSynchronousCursor)(this.db, cursorDescription);
-        var stopped = false;
-        var lastTS;
-        const loop = async () => {
-            var doc = null;
-            while (true) {
-                if (stopped)
-                    return;
-                try {
-                    doc = await cursor._nextObjectPromiseWithTimeout(timeoutMS);
-                }
-                catch (err) {
-                    // There's no good way to figure out if this was actually an error from
-                    // Mongo, or just client-side (including our own timeout error). Ah
-                    // well. But either way, we need to retry the cursor (unless the failure
-                    // was because the observe got stopped).
-                    doc = null;
-                }
-                // Since we awaited a promise above, we need to check again to see if
-                // we've been stopped before calling the callback.
-                if (stopped)
-                    return;
-                if (doc) {
-                    // If a tailable cursor contains a "ts" field, use it to recreate the
-                    // cursor on error. ("ts" is a standard that Mongo uses internally for
-                    // the oplog, and there's a special flag that lets you do binary search
-                    // on it instead of needing to use an index.)
-                    lastTS = doc.ts;
-                    docCallback(doc);
-                }
-                else {
-                    const newSelector = Object.assign({}, cursorDescription.selector);
-                    if (lastTS) {
-                        newSelector.ts = { $gt: lastTS };
-                    }
-                    const newDescription = new live_cursor_1.CursorDescription(cursorDescription.collectionName, newSelector, cursorDescription.options);
-                    cursor = (0, synchronous_cursor_1._createSynchronousCursor)(this.db, newDescription);
-                    // Mongo failover takes many seconds.  Retry in a bit.  (Without this
-                    // setTimeout, we peg the CPU at 100% and never notice the actual
-                    // failover.
-                    setTimeout(loop, 100);
-                    break;
-                }
-            }
-        };
-        setImmediate(loop);
-        return {
-            stop: function () {
-                stopped = true;
-                cursor.close();
-            }
-        };
-    }
-    async _observeChanges(cursorDescription, ordered, callbacks, nonMutatingCallbacks) {
-        var self = this;
-        if (cursorDescription.options.tailable) {
-            return self._observeChangesTailable(cursorDescription, ordered, callbacks);
-        }
-        // You may not filter out _id when observing changes, because the id is a core
-        // part of the observeChanges API.
-        const fieldsOptions = cursorDescription.options.projection;
-        if (fieldsOptions && (fieldsOptions._id === 0 || fieldsOptions._id === false))
-            throw Error("You may not observe a cursor with {fields: {_id: 0}}");
-        var observeKey = (0, ejson_1.stringify)(Object.assign({ ordered: ordered }, cursorDescription));
-        var multiplexer, observeDriver;
-        var firstHandle = false;
-        // Find a matching ObserveMultiplexer, or create a new one. This next block is
-        // guaranteed to not yield (and it doesn't call anything that can observe a
-        // new query), so no other calls to this function can interleave with it.
-        //Meteor._noYieldsAllowed(function () {
-        if (self._observeMultiplexers.hasOwnProperty(observeKey)) {
-            multiplexer = self._observeMultiplexers[observeKey];
-        }
-        else {
-            firstHandle = true;
-            // Create a new ObserveMultiplexer.
-            multiplexer = new observe_multiplexer_1.ObserveMultiplexer({
-                ordered: ordered,
-                onStop: function () {
-                    delete self._observeMultiplexers[observeKey];
-                    observeDriver.stop();
-                }
-            });
-            self._observeMultiplexers[observeKey] = multiplexer;
-        }
-        //});
-        var observeHandle = new observe_multiplexer_1.ObserveHandle(multiplexer, callbacks, nonMutatingCallbacks);
-        if (firstHandle) {
-            let matcher;
-            let sorter;
-            // At a bare minimum, using the oplog requires us to have an oplog, to
-            // want unordered callbacks, and to not want a callback on the polls
-            // that won't happen.
-            const basicPrerequisites = self._oplogHandle && !ordered && !callbacks._testOnlyPollCallback;
-            let selectorIsCompilable = false;
-            // We need to be able to compile the selector. Fall back to polling for
-            // some newfangled $selector that minimongo doesn't support yet.
-            try {
-                matcher = new minimongo_matcher_1.MinimongoMatcher(cursorDescription.selector);
-                selectorIsCompilable = true;
-            }
-            catch (e) {
-            }
-            const supportedByOplog = oplog_observe_driver_1.OplogObserveDriver.cursorSupported(cursorDescription, matcher);
-            let cursorIsSortable = false;
-            // And we need to be able to compile the sort, if any.  eg, can't be
-            // {$natural: 1}.
-            if (!cursorDescription.options.sort)
-                cursorIsSortable = true;
-            try {
-                sorter = new minimongo_sorter_1.default(cursorDescription.options.sort);
-                cursorIsSortable = true;
-            }
-            catch (e) {
-            }
-            const canUseOplog = basicPrerequisites && selectorIsCompilable && cursorIsSortable && supportedByOplog;
-            var driverClass = canUseOplog ? oplog_observe_driver_1.OplogObserveDriver : polling_observe_driver_1.PollingObserveDriver;
-            observeDriver = new driverClass({
-                cursorDescription: cursorDescription,
-                mongoHandle: self,
-                multiplexer: multiplexer,
-                ordered: ordered,
-                matcher,
-                sorter // ignored by polling
-            });
-        }
-        // Blocks until the initial adds have been sent.
-        await multiplexer.addHandleAndSendInitialAdds(observeHandle);
-        return observeHandle;
-    }
-    // observeChanges for tailable cursors on capped collections.
-    //
-    // Some differences from normal cursors:
-    //   - Will never produce anything other than 'added' or 'addedBefore'. If you
-    //     do update a document that has already been produced, this will not notice
-    //     it.
-    //   - If you disconnect and reconnect from Mongo, it will essentially restart
-    //     the query, which will lead to duplicate results. This is pretty bad,
-    //     but if you include a field called 'ts' which is inserted as
-    //     new MongoInternals.MongoTimestamp(0, 0) (which is initialized to the
-    //     current Mongo-style timestamp), we'll be able to find the place to
-    //     restart properly. (This field is specifically understood by Mongo with an
-    //     optimization which allows it to find the right place to start without
-    //     an index on ts. It's how the oplog works.)
-    //   - No callbacks are triggered synchronously with the call (there's no
-    //     differentiation between "initial data" and "later changes"; everything
-    //     that matches the query gets sent asynchronously).
-    //   - De-duplication is not implemented.
-    //   - Does not yet interact with the write fence. Probably, this should work by
-    //     ignoring removes (which don't work on capped collections) and updates
-    //     (which don't affect tailable cursors), and just keeping track of the ID
-    //     of the inserted object, and closing the write fence once you get to that
-    //     ID (or timestamp?).  This doesn't work well if the document doesn't match
-    //     the query, though.  On the other hand, the write fence can close
-    //     immediately if it does not match the query. So if we trust minimongo
-    //     enough to accurately evaluate the query against the write fence, we
-    //     should be able to do this...  Of course, minimongo doesn't even support
-    //     Mongo Timestamps yet.
-    _observeChangesTailable(cursorDescription, ordered, callbacks) {
-        var self = this;
-        // Tailable cursors only ever call added/addedBefore callbacks, so it's an
-        // error if you didn't provide them.
-        if ((ordered && !callbacks.addedBefore) ||
-            (!ordered && !callbacks.added)) {
-            throw new Error("Can't observe an " + (ordered ? "ordered" : "unordered")
-                + " tailable cursor without a "
-                + (ordered ? "addedBefore" : "added") + " callback");
-        }
-        return self.tail(cursorDescription, function (doc) {
-            var id = doc._id;
-            delete doc._id;
-            // The ts is an implementation detail. Hide it.
-            delete doc.ts;
-            if (ordered) {
-                callbacks.addedBefore(id, doc, null);
-            }
-            else {
-                callbacks.added(id, doc);
-            }
-        });
-    }
-    _onFailover(callback) {
-        return this._onFailoverHook.register(callback);
-    }
-}
-exports.LiveMongoConnection = LiveMongoConnection;
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LiveMongoConnection = void 0;
+const hook_1 = require("../callback-hook/hook");
+const mongodb_1 = require("mongodb");
+const live_cursor_1 = require("./live_cursor");
+const ejson_1 = require("../ejson/ejson");
+const synchronous_cursor_1 = require("./synchronous-cursor");
+const oplog_tailing_1 = require("./oplog_tailing");
+const doc_fetcher_1 = require("./doc_fetcher");
+const observe_multiplexer_1 = require("./observe_multiplexer");
+const polling_observe_driver_1 = require("./polling_observe_driver");
+const oplog_observe_driver_1 = require("./oplog-observe-driver");
+const minimongo_matcher_1 = require("./minimongo_matcher");
+const minimongo_sorter_1 = __importDefault(require("./minimongo_sorter"));
+class LiveMongoConnection {
+    constructor(url, options) {
+        this._oplogHandle = null;
+        this._docFetcher = null;
+        this._observeMultiplexers = {};
+        this._onFailoverHook = new hook_1.Hook();
+        options = options || {};
+        var mongoOptions = {
+            ignoreUndefined: true,
+            maxPoolSize: undefined
+        };
+        // Internally the oplog connections specify their own maxPoolSize
+        // which we don't want to overwrite with any user defined value
+        if (options.hasOwnProperty("maxPoolSize")) {
+            // If we just set this for "server", replSet will override it. If we just
+            // set it for replSet, it will be ignored if we're not using a replSet.
+            mongoOptions.maxPoolSize = options.maxPoolSize;
+        }
+        this.client = new mongodb_1.MongoClient(url, mongoOptions);
+        this.db = this.client.db();
+        this.client.on('serverDescriptionChanged', event => {
+            // When the connection is no longer against the primary node, execute all
+            // failover hooks. This is important for the driver as it has to re-pool the
+            // query when it happens.
+            if (event.previousDescription.type !== 'RSPrimary' &&
+                event.newDescription.type === 'RSPrimary') {
+                this._onFailoverHook.each(callback => {
+                    callback();
+                    return true;
+                });
+            }
+        });
+        if (options.oplogUrl) {
+            this._oplogHandle = new oplog_tailing_1.OplogHandle(options.oplogUrl, this.db.databaseName);
+            this._docFetcher = new doc_fetcher_1.DocFetcher(this.db);
+        }
+    }
+    close() {
+        var self = this;
+        if (!self.db)
+            throw Error("close called before Connection created?");
+        // XXX probably untested
+        var oplogHandle = self._oplogHandle;
+        self._oplogHandle = null;
+        if (oplogHandle)
+            oplogHandle.stop();
+        // Use Future.wrap so that errors get thrown. This happens to
+        // work even outside a fiber since the 'close' method is not
+        // actually asynchronous.
+        self.client.close(true);
+    }
+    // Tails the cursor described by cursorDescription, most likely on the
+    // oplog. Calls docCallback with each document found. Ignores errors and just
+    // restarts the tail on error.
+    //
+    // If timeoutMS is set, then if we don't get a new document every timeoutMS,
+    // kill and restart the cursor. This is primarily a workaround for #8598.
+    tail(cursorDescription, docCallback, timeoutMS) {
+        if (!cursorDescription.options.tailable)
+            throw new Error("Can only tail a tailable cursor");
+        var cursor = (0, synchronous_cursor_1._createSynchronousCursor)(this.db, cursorDescription);
+        var stopped = false;
+        var lastTS;
+        const loop = async () => {
+            var doc = null;
+            while (true) {
+                if (stopped)
+                    return;
+                try {
+                    doc = await cursor._nextObjectPromiseWithTimeout(timeoutMS);
+                }
+                catch (err) {
+                    // There's no good way to figure out if this was actually an error from
+                    // Mongo, or just client-side (including our own timeout error). Ah
+                    // well. But either way, we need to retry the cursor (unless the failure
+                    // was because the observe got stopped).
+                    doc = null;
+                }
+                // Since we awaited a promise above, we need to check again to see if
+                // we've been stopped before calling the callback.
+                if (stopped)
+                    return;
+                if (doc) {
+                    // If a tailable cursor contains a "ts" field, use it to recreate the
+                    // cursor on error. ("ts" is a standard that Mongo uses internally for
+                    // the oplog, and there's a special flag that lets you do binary search
+                    // on it instead of needing to use an index.)
+                    lastTS = doc.ts;
+                    docCallback(doc);
+                }
+                else {
+                    const newSelector = Object.assign({}, cursorDescription.selector);
+                    if (lastTS) {
+                        newSelector.ts = { $gt: lastTS };
+                    }
+                    const newDescription = new live_cursor_1.CursorDescription(cursorDescription.collectionName, newSelector, cursorDescription.options);
+                    cursor = (0, synchronous_cursor_1._createSynchronousCursor)(this.db, newDescription);
+                    // Mongo failover takes many seconds.  Retry in a bit.  (Without this
+                    // setTimeout, we peg the CPU at 100% and never notice the actual
+                    // failover.
+                    setTimeout(loop, 100);
+                    break;
+                }
+            }
+        };
+        setImmediate(loop);
+        return {
+            stop: function () {
+                stopped = true;
+                cursor.close();
+            }
+        };
+    }
+    async _observeChanges(cursorDescription, ordered, callbacks, nonMutatingCallbacks) {
+        var self = this;
+        if (cursorDescription.options.tailable) {
+            return self._observeChangesTailable(cursorDescription, ordered, callbacks);
+        }
+        // You may not filter out _id when observing changes, because the id is a core
+        // part of the observeChanges API.
+        const fieldsOptions = cursorDescription.options.projection;
+        if (fieldsOptions && (fieldsOptions._id === 0 || fieldsOptions._id === false))
+            throw Error("You may not observe a cursor with {fields: {_id: 0}}");
+        var observeKey = (0, ejson_1.stringify)(Object.assign({ ordered: ordered }, cursorDescription));
+        var multiplexer, observeDriver;
+        var firstHandle = false;
+        // Find a matching ObserveMultiplexer, or create a new one. This next block is
+        // guaranteed to not yield (and it doesn't call anything that can observe a
+        // new query), so no other calls to this function can interleave with it.
+        //Meteor._noYieldsAllowed(function () {
+        if (self._observeMultiplexers.hasOwnProperty(observeKey)) {
+            multiplexer = self._observeMultiplexers[observeKey];
+        }
+        else {
+            firstHandle = true;
+            // Create a new ObserveMultiplexer.
+            multiplexer = new observe_multiplexer_1.ObserveMultiplexer({
+                ordered: ordered,
+                onStop: function () {
+                    delete self._observeMultiplexers[observeKey];
+                    observeDriver.stop();
+                }
+            });
+            self._observeMultiplexers[observeKey] = multiplexer;
+        }
+        //});
+        var observeHandle = new observe_multiplexer_1.ObserveHandle(multiplexer, callbacks, nonMutatingCallbacks);
+        if (firstHandle) {
+            let matcher;
+            let sorter;
+            // At a bare minimum, using the oplog requires us to have an oplog, to
+            // want unordered callbacks, and to not want a callback on the polls
+            // that won't happen.
+            const basicPrerequisites = self._oplogHandle && !ordered && !callbacks._testOnlyPollCallback;
+            let selectorIsCompilable = false;
+            // We need to be able to compile the selector. Fall back to polling for
+            // some newfangled $selector that minimongo doesn't support yet.
+            try {
+                matcher = new minimongo_matcher_1.MinimongoMatcher(cursorDescription.selector);
+                selectorIsCompilable = true;
+            }
+            catch (e) {
+            }
+            const supportedByOplog = oplog_observe_driver_1.OplogObserveDriver.cursorSupported(cursorDescription, matcher);
+            let cursorIsSortable = false;
+            // And we need to be able to compile the sort, if any.  eg, can't be
+            // {$natural: 1}.
+            if (!cursorDescription.options.sort)
+                cursorIsSortable = true;
+            try {
+                sorter = new minimongo_sorter_1.default(cursorDescription.options.sort);
+                cursorIsSortable = true;
+            }
+            catch (e) {
+            }
+            const canUseOplog = basicPrerequisites && selectorIsCompilable && cursorIsSortable && supportedByOplog;
+            var driverClass = canUseOplog ? oplog_observe_driver_1.OplogObserveDriver : polling_observe_driver_1.PollingObserveDriver;
+            observeDriver = new driverClass({
+                cursorDescription: cursorDescription,
+                mongoHandle: self,
+                multiplexer: multiplexer,
+                ordered: ordered,
+                matcher, // ignored by polling
+                sorter // ignored by polling
+            });
+        }
+        // Blocks until the initial adds have been sent.
+        await multiplexer.addHandleAndSendInitialAdds(observeHandle);
+        return observeHandle;
+    }
+    // observeChanges for tailable cursors on capped collections.
+    //
+    // Some differences from normal cursors:
+    //   - Will never produce anything other than 'added' or 'addedBefore'. If you
+    //     do update a document that has already been produced, this will not notice
+    //     it.
+    //   - If you disconnect and reconnect from Mongo, it will essentially restart
+    //     the query, which will lead to duplicate results. This is pretty bad,
+    //     but if you include a field called 'ts' which is inserted as
+    //     new MongoInternals.MongoTimestamp(0, 0) (which is initialized to the
+    //     current Mongo-style timestamp), we'll be able to find the place to
+    //     restart properly. (This field is specifically understood by Mongo with an
+    //     optimization which allows it to find the right place to start without
+    //     an index on ts. It's how the oplog works.)
+    //   - No callbacks are triggered synchronously with the call (there's no
+    //     differentiation between "initial data" and "later changes"; everything
+    //     that matches the query gets sent asynchronously).
+    //   - De-duplication is not implemented.
+    //   - Does not yet interact with the write fence. Probably, this should work by
+    //     ignoring removes (which don't work on capped collections) and updates
+    //     (which don't affect tailable cursors), and just keeping track of the ID
+    //     of the inserted object, and closing the write fence once you get to that
+    //     ID (or timestamp?).  This doesn't work well if the document doesn't match
+    //     the query, though.  On the other hand, the write fence can close
+    //     immediately if it does not match the query. So if we trust minimongo
+    //     enough to accurately evaluate the query against the write fence, we
+    //     should be able to do this...  Of course, minimongo doesn't even support
+    //     Mongo Timestamps yet.
+    _observeChangesTailable(cursorDescription, ordered, callbacks) {
+        var self = this;
+        // Tailable cursors only ever call added/addedBefore callbacks, so it's an
+        // error if you didn't provide them.
+        if ((ordered && !callbacks.addedBefore) ||
+            (!ordered && !callbacks.added)) {
+            throw new Error("Can't observe an " + (ordered ? "ordered" : "unordered")
+                + " tailable cursor without a "
+                + (ordered ? "addedBefore" : "added") + " callback");
+        }
+        return self.tail(cursorDescription, function (doc) {
+            var id = doc._id;
+            delete doc._id;
+            // The ts is an implementation detail. Hide it.
+            delete doc.ts;
+            if (ordered) {
+                callbacks.addedBefore(id, doc, null);
+            }
+            else {
+                callbacks.added(id, doc);
+            }
+        });
+    }
+    _onFailover(callback) {
+        return this._onFailoverHook.register(callback);
+    }
+}
+exports.LiveMongoConnection = LiveMongoConnection;

package/dist/meteor/mongo/live_cursor.d.ts

@@ -1,25 +1,25 @@
-import { Subscription } from "../ddp/subscription";
-import * as MongoDB from "mongodb";
-import { LiveMongoConnection } from "./live_connection";
-interface CustomFindOptions<T> extends MongoDB.FindOptions<MongoDB.WithId<T>> {
-    pollingThrottleMs?: number;
-    pollingIntervalMs?: number;
-    transform?: (doc: T) => T;
-    maxTimeMs?: number;
-    disableOplog?: boolean;
-}
-export declare class CursorDescription<T> {
-    collectionName: string;
-    selector: MongoDB.Filter<MongoDB.WithId<T>>;
-    options: CustomFindOptions<MongoDB.WithId<T>>;
-    constructor(collectionName: string, selector: MongoDB.Filter<MongoDB.WithId<T>>, options?: CustomFindOptions<MongoDB.WithId<T>>);
-}
-export declare class LiveCursor<T> {
-    mongo: LiveMongoConnection;
-    cursorDescription: CursorDescription<T>;
-    constructor(mongo: LiveMongoConnection, collectionName: string, selector: MongoDB.Filter<MongoDB.WithId<T>>, options: CustomFindOptions<MongoDB.WithId<T>>);
-    _publishCursor(sub: Subscription): Promise<{
-        stop: () => void;
-    }>;
-}
-export {};
+import { Subscription } from "../ddp/subscription";
+import * as MongoDB from "mongodb";
+import { LiveMongoConnection } from "./live_connection";
+interface CustomFindOptions<T> extends MongoDB.FindOptions<MongoDB.WithId<T>> {
+    pollingThrottleMs?: number;
+    pollingIntervalMs?: number;
+    transform?: (doc: T) => T;
+    maxTimeMs?: number;
+    disableOplog?: boolean;
+}
+export declare class CursorDescription<T> {
+    collectionName: string;
+    selector: MongoDB.Filter<MongoDB.WithId<T>>;
+    options: CustomFindOptions<MongoDB.WithId<T>>;
+    constructor(collectionName: string, selector: MongoDB.Filter<MongoDB.WithId<T>>, options?: CustomFindOptions<MongoDB.WithId<T>>);
+}
+export declare class LiveCursor<T> {
+    mongo: LiveMongoConnection;
+    cursorDescription: CursorDescription<T>;
+    constructor(mongo: LiveMongoConnection, collectionName: string, selector: MongoDB.Filter<MongoDB.WithId<T>>, options: CustomFindOptions<MongoDB.WithId<T>>);
+    _publishCursor(sub: Subscription): Promise<{
+        stop: () => void;
+    }>;
+}
+export {};