mongodb-livedata-server 0.0.1

package/dist/meteor/ejson/utils.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleError = exports.checkError = exports.isInfOrNaN = exports.isArguments = exports.convertMapToObject = exports.hasOwn = exports.lengthOf = exports.keysOf = exports.isObject = exports.isFunction = void 0;
+const isFunction = (fn) => typeof fn === 'function';
+exports.isFunction = isFunction;
+const isObject = (fn) => typeof fn === 'object';
+exports.isObject = isObject;
+const keysOf = (obj) => Object.keys(obj);
+exports.keysOf = keysOf;
+const lengthOf = (obj) => Object.keys(obj).length;
+exports.lengthOf = lengthOf;
+const hasOwn = (obj, prop) => Object.prototype.hasOwnProperty.call(obj, prop);
+exports.hasOwn = hasOwn;
+const convertMapToObject = (map) => Array.from(map).reduce((acc, [key, value]) => {
+    // reassign to not create new object
+    acc[key] = value;
+    return acc;
+}, {});
+exports.convertMapToObject = convertMapToObject;
+function isArguments(obj) {
+    return obj != null && (0, exports.hasOwn)(obj, 'callee');
+}
+exports.isArguments = isArguments;
+const isInfOrNaN = obj => Number.isNaN(obj) || obj === Infinity || obj === -Infinity;
+exports.isInfOrNaN = isInfOrNaN;
+exports.checkError = {
+    maxStack: (msgError) => new RegExp('Maximum call stack size exceeded', 'g').test(msgError),
+};
+function handleError(fn, ...args) {
+    try {
+        return fn.apply(this, args);
+    }
+    catch (error) {
+        const isMaxStack = exports.checkError.maxStack(error.message);
+        if (isMaxStack) {
+            throw new Error('Converting circular structure to JSON');
+        }
+        throw error;
+    }
+}
+exports.handleError = handleError;
+;

package/dist/meteor/id-map/id_map.js

@@ -0,0 +1,92 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IdMap = void 0;
+const EJSON = __importStar(require("../ejson/ejson"));
+class IdMap {
+    constructor(idStringify, idParse) {
+        this._map = new Map();
+        this._idStringify = idStringify || JSON.stringify;
+        this._idParse = idParse || JSON.parse;
+    }
+    // Some of these methods are designed to match methods on OrderedDict, since
+    // (eg) ObserveMultiplex and _CachingChangeObserver use them interchangeably.
+    // (Conceivably, this should be replaced with "UnorderedDict" with a specific
+    // set of methods that overlap between the two.)
+    get(id) {
+        const key = this._idStringify(id);
+        return this._map.get(key);
+    }
+    set(id, value) {
+        const key = this._idStringify(id);
+        this._map.set(key, value);
+    }
+    remove(id) {
+        const key = this._idStringify(id);
+        this._map.delete(key);
+    }
+    has(id) {
+        const key = this._idStringify(id);
+        return this._map.has(key);
+    }
+    empty() {
+        return this._map.size === 0;
+    }
+    clear() {
+        this._map.clear();
+    }
+    // Iterates over the items in the map. Return `false` to break the loop.
+    forEach(iterator) {
+        // don't use _.each, because we can't break out of it.
+        for (let [key, value] of this._map) {
+            const breakIfFalse = iterator.call(null, value, this._idParse(key));
+            if (breakIfFalse === false) {
+                return;
+            }
+        }
+    }
+    size() {
+        return this._map.size;
+    }
+    setDefault(id, def) {
+        const key = this._idStringify(id);
+        if (this._map.has(key)) {
+            return this._map.get(key);
+        }
+        this._map.set(key, def);
+        return def;
+    }
+    // Assumes that values are EJSON-cloneable, and that we don't need to clone
+    // IDs (ie, that nobody is going to mutate an ObjectId).
+    clone() {
+        const clone = new IdMap(this._idStringify, this._idParse);
+        // copy directly to avoid stringify/parse overhead
+        this._map.forEach(function (value, key) {
+            clone._map.set(key, EJSON.clone(value));
+        });
+        return clone;
+    }
+}
+exports.IdMap = IdMap;

package/dist/meteor/mongo/caching_change_observer.js

@@ -0,0 +1,94 @@
+"use strict";
+// _CachingChangeObserver is an object which receives observeChanges callbacks
+// and keeps a cache of the current cursor state up to date in this.docs. Users
+// of this class should read the docs field but not modify it. You should pass
+// the "applyChange" field as the callbacks to the underlying observeChanges
+// call. Optionally, you can specify your own observeChanges callbacks which are
+// invoked immediately before the docs field is updated; this object is made
+Object.defineProperty(exports, "__esModule", { value: true });
+exports._CachingChangeObserver = void 0;
+const diff_1 = require("../diff-sequence/diff");
+const ejson_1 = require("../ejson/ejson");
+const ordered_dict_1 = require("../ordered-dict/ordered_dict");
+// available as `this` to those callbacks.
+class _CachingChangeObserver {
+    constructor(options = {}) {
+        const orderedFromCallbacks = (options.callbacks &&
+            !!(options.callbacks.addedBefore || options.callbacks.movedBefore));
+        if (options.hasOwnProperty('ordered')) {
+            this.ordered = options.ordered;
+            if (options.callbacks && options.ordered !== orderedFromCallbacks) {
+                throw Error('ordered option doesn\'t match callbacks');
+            }
+        }
+        else if (options.callbacks) {
+            this.ordered = orderedFromCallbacks;
+        }
+        else {
+            throw Error('must provide ordered or callbacks');
+        }
+        const callbacks = options.callbacks || {};
+        if (this.ordered) {
+            this.docs = new ordered_dict_1.OrderedDict();
+            this.applyChange = {
+                addedBefore: (id, fields, before) => {
+                    // Take a shallow copy since the top-level properties can be changed
+                    const doc = Object.assign({}, fields);
+                    doc._id = id;
+                    if (callbacks.addedBefore) {
+                        callbacks.addedBefore.call(this, id, (0, ejson_1.clone)(fields), before);
+                    }
+                    // This line triggers if we provide added with movedBefore.
+                    if (callbacks.added) {
+                        callbacks.added.call(this, id, (0, ejson_1.clone)(fields));
+                    }
+                    // XXX could `before` be a falsy ID?  Technically
+                    // idStringify seems to allow for them -- though
+                    // OrderedDict won't call stringify on a falsy arg.
+                    this.docs.putBefore(id, doc, before || null);
+                },
+                movedBefore: (id, before) => {
+                    const doc = this.docs.get(id);
+                    if (callbacks.movedBefore) {
+                        callbacks.movedBefore.call(this, id, before);
+                    }
+                    this.docs.moveBefore(id, before || null);
+                },
+            };
+        }
+        else {
+            this.docs = new Map();
+            this.applyChange = {
+                added: (id, fields) => {
+                    // Take a shallow copy since the top-level properties can be changed
+                    const doc = Object.assign({}, fields);
+                    if (callbacks.added) {
+                        callbacks.added.call(this, id, (0, ejson_1.clone)(fields));
+                    }
+                    doc._id = id;
+                    this.docs.set(id, doc);
+                },
+            };
+        }
+        // The methods in _IdMap and OrderedDict used by these callbacks are
+        // identical.
+        this.applyChange.changed = (id, fields) => {
+            const doc = this.docs.get(id);
+            if (!doc) {
+                throw new Error(`Unknown id for changed: ${id}`);
+            }
+            if (callbacks.changed) {
+                callbacks.changed.call(this, id, (0, ejson_1.clone)(fields));
+            }
+            diff_1.DiffSequence.applyChanges(doc, fields);
+        };
+        this.applyChange.removed = id => {
+            if (callbacks.removed) {
+                callbacks.removed.call(this, id);
+            }
+            this.docs.delete(id);
+        };
+    }
+}
+exports._CachingChangeObserver = _CachingChangeObserver;
+;

package/dist/meteor/mongo/doc_fetcher.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DocFetcher = void 0;
+const ejson_1 = require("../ejson/ejson");
+class DocFetcher {
+    constructor(db) {
+        this.db = db;
+        this._callbacksForOp = new Map();
+    }
+    // Fetches document "id" from collectionName, returning it or null if not
+    // found.
+    //
+    // If you make multiple calls to fetch() with the same op reference,
+    // DocFetcher may assume that they all return the same document. (It does
+    // not check to see if collectionName/id match.)
+    //
+    // You may assume that callback is never called synchronously (and in fact
+    // OplogObserveDriver does so).
+    async fetch(collectionName, id, op, callback) {
+        const self = this;
+        // If there's already an in-progress fetch for this cache key, yield until
+        // it's done and return whatever it returns.
+        if (self._callbacksForOp.has(op)) {
+            self._callbacksForOp.get(op).push(callback);
+            return;
+        }
+        const callbacks = [callback];
+        self._callbacksForOp.set(op, callbacks);
+        try {
+            var doc = await self.db.collection(collectionName).findOne({ _id: id }) || null;
+            // Return doc to all relevant callbacks. Note that this array can
+            // continue to grow during callback execution.
+            while (callbacks.length > 0) {
+                // Clone the document so that the various calls to fetch don't return
+                // objects that are intertwingled with each other. Clone before
+                // popping the future, so that if clone throws, the error gets passed
+                // to the next callback.
+                callbacks.pop()(null, (0, ejson_1.clone)(doc));
+            }
+        }
+        catch (e) {
+            while (callbacks.length > 0) {
+                callbacks.pop()(e);
+            }
+        }
+        finally {
+            // XXX consider keeping the doc around for a period of time before
+            // removing from the cache
+            self._callbacksForOp.delete(op);
+        }
+    }
+}
+exports.DocFetcher = DocFetcher;

package/dist/meteor/mongo/geojson_utils.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.geometryWithinRadius = exports.pointDistance = exports.numberToRadius = void 0;
+function numberToRadius(number) {
+    return number * Math.PI / 180;
+}
+exports.numberToRadius = numberToRadius;
+// from http://www.movable-type.co.uk/scripts/latlong.html
+function pointDistance(pt1, pt2) {
+    var lon1 = pt1.coordinates[0], lat1 = pt1.coordinates[1], lon2 = pt2.coordinates[0], lat2 = pt2.coordinates[1], dLat = numberToRadius(lat2 - lat1), dLon = numberToRadius(lon2 - lon1), a = Math.pow(Math.sin(dLat / 2), 2) + Math.cos(numberToRadius(lat1))
+        * Math.cos(numberToRadius(lat2)) * Math.pow(Math.sin(dLon / 2), 2), c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));
+    // Earth radius is 6371 km
+    return (6371 * c) * 1000; // returns meters
+}
+exports.pointDistance = pointDistance;
+// checks if geometry lies entirely within a circle
+// works with Point, LineString, Polygon
+function geometryWithinRadius(geometry, center, radius) {
+    if (geometry.type == 'Point') {
+        return pointDistance(geometry, center) <= radius;
+    }
+    else if (geometry.type == 'LineString' || geometry.type == 'Polygon') {
+        var point = {};
+        var coordinates;
+        if (geometry.type == 'Polygon') {
+            // it's enough to check the exterior ring of the Polygon
+            coordinates = geometry.coordinates[0];
+        }
+        else {
+            coordinates = geometry.coordinates;
+        }
+        for (var i in coordinates) {
+            point.coordinates = coordinates[i];
+            if (pointDistance(point, center) > radius) {
+                return false;
+            }
+        }
+    }
+    return true;
+}
+exports.geometryWithinRadius = geometryWithinRadius;

package/dist/meteor/mongo/live_connection.js

@@ -0,0 +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();
+            }
+        };
+    }
+    _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.
+        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.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LiveCursor = exports.CursorDescription = void 0;
+const main_1 = require("../random/main");
+class CursorDescription {
+    constructor(collectionName, selector, options) {
+        this.collectionName = collectionName;
+        var self = this;
+        self.collectionName = collectionName;
+        self.selector = _rewriteSelector(selector);
+        self.options = options || {};
+    }
+}
+exports.CursorDescription = CursorDescription;
+class LiveCursor {
+    constructor(mongo, collectionName, selector, options) {
+        this.mongo = mongo;
+        this.cursorDescription = new CursorDescription(collectionName, selector, options);
+    }
+    _publishCursor(sub) {
+        const observeHandle = this.mongo._observeChanges(this.cursorDescription, false, {
+            added: (id, fields) => {
+                sub.added(this.cursorDescription.collectionName, id, fields);
+            },
+            changed: (id, fields) => {
+                sub.changed(this.cursorDescription.collectionName, id, fields);
+            },
+            removed: (id) => {
+                sub.removed(this.cursorDescription.collectionName, id);
+            },
+        }, 
+        // Publications don't mutate the documents
+        // This is tested by the `livedata - publish callbacks clone` test
+        true);
+        // We don't call sub.ready() here: it gets called in livedata_server, after
+        // possibly calling _publishCursor on multiple returned cursors.
+        // register stop callback (expects lambda w/ no args).
+        sub.onStop(function () {
+            observeHandle.stop();
+        });
+        // return the observeHandle in case it needs to be stopped early
+        return observeHandle;
+    }
+}
+exports.LiveCursor = LiveCursor;
+function _rewriteSelector(selector) {
+    if (Array.isArray(selector)) {
+        // This is consistent with the Mongo console itself; if we don't do this
+        // check passing an empty array ends up selecting all items
+        throw new Error("Mongo selector can't be an array.");
+    }
+    if (!selector || ('_id' in selector && !selector._id)) {
+        // can't match anything
+        return { _id: main_1.Random.id() };
+    }
+    return selector;
+}