mongodb-livedata-server 0.0.1

package/dist/meteor/mongo/synchronous-cursor.js

@@ -0,0 +1,261 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SynchronousCursor = exports._createSynchronousCursor = void 0;
+const ejson_1 = require("../ejson/ejson");
+const oplog_tailing_1 = require("./oplog_tailing");
+function _createSynchronousCursor(db, cursorDescription, options) {
+    const { useTransform } = options || {};
+    var collection = db.collection(cursorDescription.collectionName);
+    var cursorOptions = cursorDescription.options;
+    var mongoOptions = {
+        sort: cursorOptions.sort,
+        limit: cursorOptions.limit,
+        skip: cursorOptions.skip,
+        projection: cursorOptions.projection,
+        readPreference: cursorOptions.readPreference,
+        numberOfRetries: undefined
+    };
+    // Do we want a tailable cursor (which only works on capped collections)?
+    if (cursorOptions.tailable) {
+        mongoOptions.numberOfRetries = -1;
+    }
+    var dbCursor = collection.find(cursorDescription.selector, mongoOptions);
+    // Do we want a tailable cursor (which only works on capped collections)?
+    if (cursorOptions.tailable) {
+        // We want a tailable cursor...
+        dbCursor.addCursorFlag("tailable", true);
+        // ... and for the server to wait a bit if any getMore has no data (rather
+        // than making us put the relevant sleeps in the client)...
+        dbCursor.addCursorFlag("awaitData", true);
+        // And if this is on the oplog collection and the cursor specifies a 'ts',
+        // then set the undocumented oplog replay flag, which does a special scan to
+        // find the first document (instead of creating an index on ts). This is a
+        // very hard-coded Mongo flag which only works on the oplog collection and
+        // only works with the ts field.
+        if (cursorDescription.collectionName === oplog_tailing_1.OPLOG_COLLECTION &&
+            cursorDescription.selector.ts) {
+            dbCursor.addCursorFlag("oplogReplay", true);
+        }
+    }
+    if (typeof cursorOptions.maxTimeMs !== 'undefined') {
+        dbCursor = dbCursor.maxTimeMS(cursorOptions.maxTimeMs);
+    }
+    if (typeof cursorOptions.hint !== 'undefined') {
+        dbCursor = dbCursor.hint(cursorOptions.hint);
+    }
+    return new SynchronousCursor(dbCursor, cursorDescription, { useTransform });
+}
+exports._createSynchronousCursor = _createSynchronousCursor;
+;
+class SynchronousCursor {
+    constructor(_dbCursor, _cursorDescription, options) {
+        this._dbCursor = _dbCursor;
+        this._cursorDescription = _cursorDescription;
+        var self = this;
+        if (options.useTransform && _cursorDescription.options.transform) {
+            self._transform = wrapTransform(_cursorDescription.options.transform);
+        }
+        else {
+            self._transform = null;
+        }
+        self._visitedIds = new Set();
+    }
+    // Returns a Promise for the next object from the cursor, skipping those whose
+    // IDs we've already seen and replacing Mongo atoms with Meteor atoms.
+    async _nextObjectPromise() {
+        var self = this;
+        while (true) {
+            var doc = await this._dbCursor.next();
+            if (!doc)
+                return null;
+            if (!self._cursorDescription.options.tailable && doc.hasOwnProperty('_id')) {
+                // Did Mongo give us duplicate documents in the same cursor? If so,
+                // ignore this one. (Do this before the transform, since transform might
+                // return some unrelated value.) We don't do this for tailable cursors,
+                // because we want to maintain O(1) memory usage. And if there isn't _id
+                // for some reason (maybe it's the oplog), then we don't do this either.
+                // (Be careful to do this for falsey but existing _id, though.)
+                if (self._visitedIds.has(doc._id))
+                    continue;
+                self._visitedIds.add(doc._id);
+            }
+            if (self._transform)
+                doc = self._transform(doc);
+            return doc;
+        }
+    }
+    // Returns a promise which is resolved with the next object (like with
+    // _nextObjectPromise) or rejected if the cursor doesn't return within
+    // timeoutMS ms.
+    async _nextObjectPromiseWithTimeout(timeoutMS) {
+        if (!timeoutMS) {
+            return this._nextObjectPromise();
+        }
+        const nextObjectPromise = this._nextObjectPromise();
+        const timeoutErr = new Error('Client-side timeout waiting for next object');
+        const timeoutPromise = new Promise((_resolve, reject) => {
+            setTimeout(() => {
+                reject(timeoutErr);
+            }, timeoutMS);
+        });
+        return Promise.race([nextObjectPromise, timeoutPromise])
+            .catch((err) => {
+            if (err === timeoutErr) {
+                this._dbCursor.close();
+            }
+            throw err;
+        });
+    }
+    close() {
+        this._dbCursor.close();
+    }
+    async forEach(callback, thisArg) {
+        var self = this;
+        // Get back to the beginning.
+        self._rewind();
+        // We implement the loop ourself instead of using self._dbCursor.each,
+        // because "each" will call its callback outside of a fiber which makes it
+        // much more complex to make this function synchronous.
+        var index = 0;
+        while (true) {
+            var doc = await self._nextObjectPromise();
+            if (!doc)
+                return;
+            callback.call(thisArg, doc, index++, self);
+        }
+    }
+    _rewind() {
+        var self = this;
+        // known to be synchronous
+        self._dbCursor.rewind();
+        self._visitedIds = new Set();
+    }
+}
+exports.SynchronousCursor = SynchronousCursor;
+// Wrap a transform function to return objects that have the _id field
+// of the untransformed document. This ensures that subsystems such as
+// the observe-sequence package that call `observe` can keep track of
+// the documents identities.
+//
+// - Require that it returns objects
+// - If the return value has an _id field, verify that it matches the
+//   original _id field
+// - If the return value doesn't have an _id field, add it back.
+function wrapTransform(transform) {
+    if (!transform)
+        return null;
+    // No need to doubly-wrap transforms.
+    if (transform.__wrappedTransform__)
+        return transform;
+    const wrapped = doc => {
+        if (!doc.hasOwnProperty('_id')) {
+            // XXX do we ever have a transform on the oplog's collection? because that
+            // collection has no _id.
+            throw new Error('can only transform documents with _id');
+        }
+        const id = doc._id;
+        const transformed = transform(doc);
+        if (transformed.hasOwnProperty('_id')) {
+            if (!(0, ejson_1.equals)(transformed._id, id)) {
+                throw new Error('transformed document can\'t have different _id');
+            }
+        }
+        else {
+            transformed._id = id;
+        }
+        return transformed;
+    };
+    wrapped.__wrappedTransform__ = true;
+    return wrapped;
+}
+;
+/*
+    forEach(callback, thisArg) {
+        var self = this;
+
+        // Get back to the beginning.
+        self._rewind();
+
+        // We implement the loop ourself instead of using self._dbCursor.each,
+        // because "each" will call its callback outside of a fiber which makes it
+        // much more complex to make this function synchronous.
+        var index = 0;
+        while (true) {
+            var doc = self._nextObject();
+            if (!doc) return;
+            callback.call(thisArg, doc, index++, self._selfForIteration);
+        }
+    }
+
+    // XXX Allow overlapping callback executions if callback yields.
+    map(callback, thisArg) {
+        var self = this;
+        var res = [];
+        self.forEach(function (doc, index) {
+            res.push(callback.call(thisArg, doc, index, self._selfForIteration));
+        });
+        return res;
+    },
+
+    _rewind() {
+        var self = this;
+
+        // known to be synchronous
+        self._dbCursor.rewind();
+
+        self._visitedIds = new LocalCollection._IdMap;
+    }
+
+    // Mostly usable for tailable cursors.
+    close() {
+        var self = this;
+
+        self._dbCursor.close();
+    }
+
+    fetch() {
+        var self = this;
+        return self.map(_.identity);
+    }
+
+    // This method is NOT wrapped in Cursor.
+    getRawObjects(ordered) {
+        var self = this;
+        if (ordered) {
+            return self.fetch();
+        } else {
+            var results = new LocalCollection._IdMap;
+            self.forEach(function (doc) {
+                results.set(doc._id, doc);
+            });
+            return results;
+        }
+    }
+
+    [Symbol.iterator]() {
+        var self = this;
+
+        // Get back to the beginning.
+        self._rewind();
+
+        return {
+            next() {
+                const doc = self._nextObject();
+                return doc ? {
+                    value: doc
+                } : {
+                    done: true
+                };
+            }
+        };
+    };
+
+    [Symbol.asyncIterator]() {
+        const syncResult = this[Symbol.iterator]();
+        return {
+            async next() {
+                return Promise.resolve(syncResult.next());
+            }
+        };
+    }
+*/ 

package/dist/meteor/mongo/synchronous-queue.js

@@ -0,0 +1,110 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports._SynchronousQueue = void 0;
+const double_ended_queue_1 = __importDefault(require("double-ended-queue"));
+class _SynchronousQueue {
+    constructor() {
+        // List of tasks to run (not including a currently-running task if any). Each
+        // is an object with field 'task' (the task function to run) and 'future' (the
+        // Future associated with the blocking runTask call that queued it, or null if
+        // called from queueTask).
+        this._taskHandles = new double_ended_queue_1.default();
+        // This is true if self._run() is either currently executing or scheduled to
+        // do so soon.
+        this._runningOrRunScheduled = false;
+        // This is true if we're currently draining.  While we're draining, a further
+        // drain is a noop, to prevent infinite loops.  "drain" is a heuristic type
+        // operation, that has a meaning like unto "what a naive person would expect
+        // when modifying a table from an observe"
+        this._draining = false;
+    }
+    async runTask(task) {
+        return new Promise((resolve, reject) => {
+            var handle = {
+                task: task,
+                name: task.name,
+                runTaskResolve: resolve,
+                runTaskReject: reject
+            };
+            this._taskHandles.push(handle);
+            this._scheduleRun();
+            // Yield. We'll get back here after the task is run (and will throw if the
+            // task throws).
+        });
+    }
+    queueTask(task) {
+        var self = this;
+        self._taskHandles.push({
+            task: task,
+            name: task.name
+        });
+        self._scheduleRun();
+        // No need to block.
+    }
+    async flush() {
+        var self = this;
+        await self.runTask(async () => { });
+    }
+    async drain() {
+        var self = this;
+        if (self._draining)
+            return;
+        self._draining = true;
+        while (!self._taskHandles.isEmpty()) {
+            await self.flush();
+        }
+        self._draining = false;
+    }
+    ;
+    _scheduleRun() {
+        // Already running or scheduled? Do nothing.
+        if (this._runningOrRunScheduled)
+            return;
+        this._runningOrRunScheduled = true;
+        setImmediate(async () => {
+            await this._run();
+        });
+    }
+    ;
+    async _run() {
+        var self = this;
+        if (!self._runningOrRunScheduled)
+            throw new Error("expected to be _runningOrRunScheduled");
+        if (self._taskHandles.isEmpty()) {
+            // Done running tasks! Don't immediately schedule another run, but
+            // allow future tasks to do so.
+            self._runningOrRunScheduled = false;
+            return;
+        }
+        var taskHandle = self._taskHandles.shift();
+        // Run the task.
+        var exception = undefined;
+        try {
+            await taskHandle.task();
+        }
+        catch (err) {
+            if (taskHandle.runTaskReject) {
+                // We'll throw this exception through runTask.
+                exception = err;
+            }
+            else {
+                console.error("Exception in queued task", err);
+            }
+        }
+        // Soon, run the next task, if there is any.
+        self._runningOrRunScheduled = false;
+        self._scheduleRun();
+        // If this was queued with runTask, let the runTask call return (throwing if
+        // the task threw).
+        if (taskHandle.runTaskReject) {
+            if (exception)
+                taskHandle.runTaskReject(exception);
+            else
+                taskHandle.runTaskResolve();
+        }
+    }
+}
+exports._SynchronousQueue = _SynchronousQueue;

package/dist/meteor/ordered-dict/ordered_dict.js

@@ -0,0 +1,198 @@
+"use strict";
+// This file defines an ordered dictionary abstraction that is useful for
+// maintaining a dataset backed by observeChanges.  It supports ordering items
+// by specifying the item they now come before.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OrderedDict = void 0;
+// The implementation is a dictionary that contains nodes of a doubly-linked
+// list as its values.
+// constructs a new element struct
+// next and prev are whole elements, not keys.
+function element(key, value, next, prev) {
+    return {
+        key: key,
+        value: value,
+        next: next,
+        prev: prev
+    };
+}
+class OrderedDict {
+    constructor(...args) {
+        this._dict = Object.create(null);
+        this._first = null;
+        this._last = null;
+        this._size = 0;
+        if (typeof args[0] === 'function') {
+            this._stringify = args.shift();
+        }
+        else {
+            this._stringify = function (x) { return x; };
+        }
+        args.forEach(kv => this.putBefore(kv[0], kv[1], null));
+    }
+    // the "prefix keys with a space" thing comes from here
+    // https://github.com/documentcloud/underscore/issues/376#issuecomment-2815649
+    _k(key) {
+        return " " + this._stringify(key);
+    }
+    empty() {
+        return !this._first;
+    }
+    size() {
+        return this._size;
+    }
+    _linkEltIn(elt) {
+        if (!elt.next) {
+            elt.prev = this._last;
+            if (this._last)
+                this._last.next = elt;
+            this._last = elt;
+        }
+        else {
+            elt.prev = elt.next.prev;
+            elt.next.prev = elt;
+            if (elt.prev)
+                elt.prev.next = elt;
+        }
+        if (this._first === null || this._first === elt.next)
+            this._first = elt;
+    }
+    _linkEltOut(elt) {
+        if (elt.next)
+            elt.next.prev = elt.prev;
+        if (elt.prev)
+            elt.prev.next = elt.next;
+        if (elt === this._last)
+            this._last = elt.prev;
+        if (elt === this._first)
+            this._first = elt.next;
+    }
+    putBefore(key, item, before) {
+        if (this._dict[this._k(key)])
+            throw new Error("Item " + key + " already present in OrderedDict");
+        var elt = before ?
+            element(key, item, this._dict[this._k(before)]) :
+            element(key, item, null);
+        if (typeof elt.next === "undefined")
+            throw new Error("could not find item to put this one before");
+        this._linkEltIn(elt);
+        this._dict[this._k(key)] = elt;
+        this._size++;
+    }
+    append(key, item) {
+        this.putBefore(key, item, null);
+    }
+    remove(key) {
+        var elt = this._dict[this._k(key)];
+        if (typeof elt === "undefined")
+            throw new Error("Item " + key + " not present in OrderedDict");
+        this._linkEltOut(elt);
+        this._size--;
+        delete this._dict[this._k(key)];
+        return elt.value;
+    }
+    get(key) {
+        if (this.has(key)) {
+            return this._dict[this._k(key)].value;
+        }
+    }
+    has(key) {
+        return Object.prototype.hasOwnProperty.call(this._dict, this._k(key));
+    }
+    // Iterate through the items in this dictionary in order, calling
+    // iter(value, key, index) on each one.
+    // Stops whenever iter returns OrderedDict.BREAK, or after the last element.
+    forEach(iter, context = null) {
+        var i = 0;
+        var elt = this._first;
+        while (elt !== null) {
+            var b = iter.call(context, elt.value, elt.key, i);
+            if (b === OrderedDict.BREAK)
+                return;
+            elt = elt.next;
+            i++;
+        }
+    }
+    first() {
+        if (this.empty()) {
+            return;
+        }
+        return this._first.key;
+    }
+    firstValue() {
+        if (this.empty()) {
+            return;
+        }
+        return this._first.value;
+    }
+    last() {
+        if (this.empty()) {
+            return;
+        }
+        return this._last.key;
+    }
+    lastValue() {
+        if (this.empty()) {
+            return;
+        }
+        return this._last.value;
+    }
+    prev(key) {
+        if (this.has(key)) {
+            var elt = this._dict[this._k(key)];
+            if (elt.prev)
+                return elt.prev.key;
+        }
+        return null;
+    }
+    next(key) {
+        if (this.has(key)) {
+            var elt = this._dict[this._k(key)];
+            if (elt.next)
+                return elt.next.key;
+        }
+        return null;
+    }
+    moveBefore(key, before) {
+        var elt = this._dict[this._k(key)];
+        var eltBefore = before ? this._dict[this._k(before)] : null;
+        if (typeof elt === "undefined") {
+            throw new Error("Item to move is not present");
+        }
+        if (typeof eltBefore === "undefined") {
+            throw new Error("Could not find element to move this one before");
+        }
+        if (eltBefore === elt.next) // no moving necessary
+            return;
+        // remove from its old place
+        this._linkEltOut(elt);
+        // patch into its new place
+        elt.next = eltBefore;
+        this._linkEltIn(elt);
+    }
+    // Linear, sadly.
+    indexOf(key) {
+        var ret = null;
+        this.forEach((v, k, i) => {
+            if (this._k(k) === this._k(key)) {
+                ret = i;
+                return OrderedDict.BREAK;
+            }
+            return;
+        });
+        return ret;
+    }
+    _checkRep() {
+        Object.keys(this._dict).forEach(k => {
+            const v = this._dict[k];
+            if (v.next === v) {
+                throw new Error("Next is a loop");
+            }
+            if (v.prev === v) {
+                throw new Error("Prev is a loop");
+            }
+        });
+    }
+}
+exports.OrderedDict = OrderedDict;
+OrderedDict.BREAK = { "break": true };

package/dist/meteor/random/AbstractRandomGenerator.js

@@ -0,0 +1,92 @@
+"use strict";
+// We use cryptographically strong PRNGs (crypto.getRandomBytes() on the server,
+// window.crypto.getRandomValues() in the browser) when available. If these
+// PRNGs fail, we fall back to the Alea PRNG, which is not cryptographically
+// strong, and we seed it with various sources such as the date, Math.random,
+// and window size on the client.  When using crypto.getRandomValues(), our
+// primitive is hexString(), from which we construct fraction(). When using
+// window.crypto.getRandomValues() or alea, the primitive is fraction and we use
+// that to construct hex string.
+Object.defineProperty(exports, "__esModule", { value: true });
+const UNMISTAKABLE_CHARS = '23456789ABCDEFGHJKLMNPQRSTWXYZabcdefghijkmnopqrstuvwxyz';
+const BASE64_CHARS = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ' +
+    '0123456789-_';
+// `type` is one of `RandomGenerator.Type` as defined below.
+//
+// options:
+// - seeds: (required, only for RandomGenerator.Type.ALEA) an array
+//   whose items will be `toString`ed and used as the seed to the Alea
+//   algorithm
+class RandomGenerator {
+    /**
+     * @name Random.fraction
+     * @summary Return a number between 0 and 1, like `Math.random`.
+     * @locus Anywhere
+     */
+    fraction() {
+        throw new Error(`Unknown random generator type`);
+    }
+    /**
+     * @name Random.hexString
+     * @summary Return a random string of `n` hexadecimal digits.
+     * @locus Anywhere
+     * @param {Number} n Length of the string
+     */
+    hexString(digits) {
+        return this._randomString(digits, '0123456789abcdef');
+    }
+    _randomString(charsCount, alphabet) {
+        let result = '';
+        for (let i = 0; i < charsCount; i++) {
+            result += this.choice(alphabet);
+        }
+        return result;
+    }
+    /**
+     * @name Random.id
+     * @summary Return a unique identifier, such as `"Jjwjg6gouWLXhMGKW"`, that is
+     * likely to be unique in the whole world.
+     * @locus Anywhere
+     * @param {Number} [n] Optional length of the identifier in characters
+     *   (defaults to 17)
+     */
+    id(charsCount) {
+        // 17 characters is around 96 bits of entropy, which is the amount of
+        // state in the Alea PRNG.
+        if (charsCount === undefined) {
+            charsCount = 17;
+        }
+        return this._randomString(charsCount, UNMISTAKABLE_CHARS);
+    }
+    /**
+     * @name Random.secret
+     * @summary Return a random string of printable characters with 6 bits of
+     * entropy per character. Use `Random.secret` for security-critical secrets
+     * that are intended for machine, rather than human, consumption.
+     * @locus Anywhere
+     * @param {Number} [n] Optional length of the secret string (defaults to 43
+     *   characters, or 256 bits of entropy)
+     */
+    secret(charsCount) {
+        // Default to 256 bits of entropy, or 43 characters at 6 bits per
+        // character.
+        if (charsCount === undefined) {
+            charsCount = 43;
+        }
+        return this._randomString(charsCount, BASE64_CHARS);
+    }
+    /**
+     * @name Random.choice
+     * @summary Return a random element of the given array or string.
+     * @locus Anywhere
+     * @param {Array|String} arrayOrString Array or string to choose from
+     */
+    choice(arrayOrString) {
+        const index = Math.floor(this.fraction() * arrayOrString.length);
+        if (typeof arrayOrString === 'string') {
+            return arrayOrString.substr(index, 1);
+        }
+        return arrayOrString[index];
+    }
+}
+exports.default = RandomGenerator;