mongodb-livedata-server 0.0.1

package/dist/meteor/mongo/minimongo_matcher.js

@@ -0,0 +1,217 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MinimongoMatcher = void 0;
+const minimongo_common_1 = require("./minimongo_common");
+const ejson_1 = require("../ejson/ejson");
+// The minimongo selector compiler!
+// Terminology:
+//  - a 'selector' is the EJSON object representing a selector
+//  - a 'matcher' is its compiled form (whether a full Minimongo.Matcher
+//    object or one of the component lambdas that matches parts of it)
+//  - a 'result object' is an object with a 'result' field and maybe
+//    distance and arrayIndices.
+//  - a 'branched value' is an object with a 'value' field and maybe
+//    'dontIterate' and 'arrayIndices'.
+//  - a 'document' is a top-level object that can be stored in a collection.
+//  - a 'lookup function' is a function that takes in a document and returns
+//    an array of 'branched values'.
+//  - a 'branched matcher' maps from an array of branched values to a result
+//    object.
+//  - an 'element matcher' maps from a single value to a bool.
+// Main entry point.
+//   var matcher = new Minimongo.Matcher({a: {$gt: 5}});
+//   if (matcher.documentMatches({a: 7})) ...
+class MinimongoMatcher {
+    constructor(selector, isUpdate) {
+        this.canBecomeTrueByModifier = function (modifier) {
+            if (!this.affectedByModifier(modifier)) {
+                return false;
+            }
+            if (!this.isSimple()) {
+                return true;
+            }
+            modifier = Object.assign({ $set: {}, $unset: {} }, modifier);
+            const modifierPaths = [].concat(Object.keys(modifier.$set), Object.keys(modifier.$unset));
+            if (this._getPaths().some(pathHasNumericKeys) ||
+                modifierPaths.some(pathHasNumericKeys)) {
+                return true;
+            }
+            // check if there is a $set or $unset that indicates something is an
+            // object rather than a scalar in the actual object where we saw $-operator
+            // NOTE: it is correct since we allow only scalars in $-operators
+            // Example: for selector {'a.b': {$gt: 5}} the modifier {'a.b.c':7} would
+            // definitely set the result to false as 'a.b' appears to be an object.
+            const expectedScalarIsObject = Object.keys(this._selector).some(path => {
+                if (!(0, minimongo_common_1.isOperatorObject)(this._selector[path])) {
+                    return false;
+                }
+                return modifierPaths.some(modifierPath => modifierPath.startsWith(`${path}.`));
+            });
+            if (expectedScalarIsObject) {
+                return false;
+            }
+            // See if we can apply the modifier on the ideally matching object. If it
+            // still matches the selector, then the modifier could have turned the real
+            // object in the database into something matching.
+            const matchingDocument = (0, ejson_1.clone)(this.matchingDocument());
+            // The selector is too complex, anything can happen.
+            if (matchingDocument === null) {
+                return true;
+            }
+            try {
+                (0, minimongo_common_1._modify)(matchingDocument, modifier);
+            }
+            catch (error) {
+                // Couldn't set a property on a field which is a scalar or null in the
+                // selector.
+                // Example:
+                // real document: { 'a.b': 3 }
+                // selector: { 'a': 12 }
+                // converted selector (ideal document): { 'a': 12 }
+                // modifier: { $set: { 'a.b': 4 } }
+                // We don't know what real document was like but from the error raised by
+                // $set on a scalar field we can reason that the structure of real document
+                // is completely different.
+                if (error.name === 'MinimongoError' && error.setPropertyError) {
+                    return false;
+                }
+                throw error;
+            }
+            return this.documentMatches(matchingDocument).result;
+        };
+        // A set (object mapping string -> *) of all of the document paths looked
+        // at by the selector. Also includes the empty string if it may look at any
+        // path (eg, $where).
+        this._paths = {};
+        // Set to true if compilation finds a $near.
+        this._hasGeoQuery = false;
+        // Set to true if compilation finds a $where.
+        this._hasWhere = false;
+        // Set to false if compilation finds anything other than a simple equality
+        // or one or more of '$gt', '$gte', '$lt', '$lte', '$ne', '$in', '$nin' used
+        // with scalars as operands.
+        this._isSimple = true;
+        // Set to a dummy document which always matches this Matcher. Or set to null
+        // if such document is too hard to find.
+        this._matchingDocument = undefined;
+        // A clone of the original selector. It may just be a function if the user
+        // passed in a function; otherwise is definitely an object (eg, IDs are
+        // translated into {_id: ID} first. Used by canBecomeTrueByModifier and
+        // Sorter._useWithMatcher.
+        this._selector = null;
+        this._docMatcher = this._compileSelector(selector);
+        // Set to true if selection is done for an update operation
+        // Default is false
+        // Used for $near array update (issue #3599)
+        this._isUpdate = isUpdate;
+    }
+    documentMatches(doc) {
+        if (doc !== Object(doc)) {
+            throw Error('documentMatches needs a document');
+        }
+        return this._docMatcher(doc);
+    }
+    hasGeoQuery() {
+        return this._hasGeoQuery;
+    }
+    hasWhere() {
+        return this._hasWhere;
+    }
+    isSimple() {
+        return this._isSimple;
+    }
+    // Given a selector, return a function that takes one argument, a
+    // document. It returns a result object.
+    _compileSelector(selector) {
+        // you can pass a literal function instead of a selector
+        if (selector instanceof Function) {
+            this._isSimple = false;
+            this._selector = selector;
+            this._recordPathUsed('');
+            return doc => ({ result: !!selector.call(doc) });
+        }
+        // protect against dangerous selectors.  falsey and {_id: falsey} are both
+        // likely programmer error, and not what you want, particularly for
+        // destructive operations.
+        if (!selector || minimongo_common_1.hasOwn.call(selector, '_id') && !selector._id) {
+            this._isSimple = false;
+            return minimongo_common_1.nothingMatcher;
+        }
+        // Top level can't be an array or true or binary.
+        if (Array.isArray(selector) ||
+            (0, ejson_1.isBinary)(selector) ||
+            typeof selector === 'boolean') {
+            throw new Error(`Invalid selector: ${selector}`);
+        }
+        this._selector = (0, ejson_1.clone)(selector);
+        return (0, minimongo_common_1.compileDocumentSelector)(selector, this, { isRoot: true });
+    }
+    affectedByModifier(modifier) {
+        // safe check for $set/$unset being objects
+        modifier = Object.assign({ $set: {}, $unset: {} }, modifier);
+        const meaningfulPaths = this._getPaths();
+        const modifiedPaths = [].concat(Object.keys(modifier.$set), Object.keys(modifier.$unset));
+        return modifiedPaths.some(path => {
+            const mod = path.split('.');
+            return meaningfulPaths.some(meaningfulPath => {
+                const sel = meaningfulPath.split('.');
+                let i = 0, j = 0;
+                while (i < sel.length && j < mod.length) {
+                    if ((0, minimongo_common_1.isNumericKey)(sel[i]) && (0, minimongo_common_1.isNumericKey)(mod[j])) {
+                        // foo.4.bar selector affected by foo.4 modifier
+                        // foo.3.bar selector unaffected by foo.4 modifier
+                        if (sel[i] === mod[j]) {
+                            i++;
+                            j++;
+                        }
+                        else {
+                            return false;
+                        }
+                    }
+                    else if ((0, minimongo_common_1.isNumericKey)(sel[i])) {
+                        // foo.4.bar selector unaffected by foo.bar modifier
+                        return false;
+                    }
+                    else if ((0, minimongo_common_1.isNumericKey)(mod[j])) {
+                        j++;
+                    }
+                    else if (sel[i] === mod[j]) {
+                        i++;
+                        j++;
+                    }
+                    else {
+                        return false;
+                    }
+                }
+                // One is a prefix of another, taking numeric fields into account
+                return true;
+            });
+        });
+    }
+    // Knows how to combine a mongo selector and a fields projection to a new fields
+    // projection taking into account active fields from the passed selector.
+    // @returns Object - projection object (same as fields option of mongo cursor)
+    combineIntoProjection(projection) {
+        const selectorPaths = (0, minimongo_common_1._pathsElidingNumericKeys)(this._getPaths());
+        // Special case for $where operator in the selector - projection should depend
+        // on all fields of the document. getSelectorPaths returns a list of paths
+        // selector depends on. If one of the paths is '' (empty string) representing
+        // the root or the whole document, complete projection should be returned.
+        if (selectorPaths.includes('')) {
+            return {};
+        }
+        return (0, minimongo_common_1.combineImportantPathsIntoProjection)(selectorPaths, projection);
+    }
+    // Returns a list of key paths the given selector is looking for. It includes
+    // the empty string if there is a $where.
+    _getPaths() {
+        return Object.keys(this._paths);
+    }
+    _recordPathUsed(path) {
+        this._paths[path] = true;
+    }
+}
+exports.MinimongoMatcher = MinimongoMatcher;
+function pathHasNumericKeys(path) {
+    return path.split('.').some(minimongo_common_1.isNumericKey);
+}

package/dist/meteor/mongo/minimongo_sorter.js

@@ -0,0 +1,268 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const minimongo_common_1 = require("./minimongo_common");
+const minimongo_matcher_1 = require("./minimongo_matcher");
+// Give a sort spec, which can be in any of these forms:
+//   {"key1": 1, "key2": -1}
+//   [["key1", "asc"], ["key2", "desc"]]
+//   ["key1", ["key2", "desc"]]
+//
+// (.. with the first form being dependent on the key enumeration
+// behavior of your javascript VM, which usually does what you mean in
+// this case if the key names don't look like integers ..)
+//
+// return a function that takes two objects, and returns -1 if the
+// first object comes first in order, 1 if the second object comes
+// first, or 0 if neither object comes before the other.
+class MinimongoSorter {
+    constructor(spec) {
+        this.combineIntoProjection = function (projection) {
+            return (0, minimongo_common_1.combineImportantPathsIntoProjection)((0, minimongo_common_1._pathsElidingNumericKeys)(this._getPaths()), projection);
+        };
+        this._sortSpecParts = [];
+        this._sortFunction = null;
+        const addSpecPart = (path, ascending) => {
+            if (!path) {
+                throw Error('sort keys must be non-empty');
+            }
+            if (path.charAt(0) === '$') {
+                throw Error(`unsupported sort key: ${path}`);
+            }
+            this._sortSpecParts.push({
+                ascending,
+                lookup: (0, minimongo_common_1.makeLookupFunction)(path, { forSort: true }),
+                path
+            });
+        };
+        if (spec instanceof Array) {
+            spec.forEach(element => {
+                if (typeof element === 'string') {
+                    addSpecPart(element, true);
+                }
+                else {
+                    addSpecPart(element[0], element[1] !== 'desc');
+                }
+            });
+        }
+        else if (typeof spec === 'object') {
+            Object.keys(spec).forEach(key => {
+                addSpecPart(key, spec[key] >= 0);
+            });
+        }
+        else if (typeof spec === 'function') {
+            this._sortFunction = spec;
+        }
+        else {
+            throw Error(`Bad sort specification: ${JSON.stringify(spec)}`);
+        }
+        // If a function is specified for sorting, we skip the rest.
+        if (this._sortFunction) {
+            return;
+        }
+        // To implement affectedByModifier, we piggy-back on top of Matcher's
+        // affectedByModifier code; we create a selector that is affected by the
+        // same modifiers as this sort order. This is only implemented on the
+        // server.
+        if (this.affectedByModifier) {
+            const selector = {};
+            this._sortSpecParts.forEach(spec => {
+                selector[spec.path] = 1;
+            });
+            this._selectorForAffectedByModifier = new minimongo_matcher_1.MinimongoMatcher(selector);
+        }
+        this._keyComparator = composeComparators(this._sortSpecParts.map((spec, i) => this._keyFieldComparator(i)));
+    }
+    affectedByModifier(modifier) {
+        return this._selectorForAffectedByModifier.affectedByModifier(modifier);
+    }
+    getComparator(options) {
+        // If sort is specified or have no distances, just use the comparator from
+        // the source specification (which defaults to "everything is equal".
+        // issue #3599
+        // https://docs.mongodb.com/manual/reference/operator/query/near/#sort-operation
+        // sort effectively overrides $near
+        if (this._sortSpecParts.length || !options || !options.distances) {
+            return this._getBaseComparator();
+        }
+        const distances = options.distances;
+        // Return a comparator which compares using $near distances.
+        return (a, b) => {
+            if (!distances.has(a._id)) {
+                throw Error(`Missing distance for ${a._id}`);
+            }
+            if (!distances.has(b._id)) {
+                throw Error(`Missing distance for ${b._id}`);
+            }
+            return distances.get(a._id) - distances.get(b._id);
+        };
+    }
+    // Takes in two keys: arrays whose lengths match the number of spec
+    // parts. Returns negative, 0, or positive based on using the sort spec to
+    // compare fields.
+    _compareKeys(key1, key2) {
+        if (key1.length !== this._sortSpecParts.length ||
+            key2.length !== this._sortSpecParts.length) {
+            throw Error('Key has wrong length');
+        }
+        return this._keyComparator(key1, key2);
+    }
+    // Iterates over each possible "key" from doc (ie, over each branch), calling
+    // 'cb' with the key.
+    _generateKeysFromDoc(doc, cb) {
+        if (this._sortSpecParts.length === 0) {
+            throw new Error('can\'t generate keys without a spec');
+        }
+        const pathFromIndices = indices => `${indices.join(',')},`;
+        let knownPaths = null;
+        // maps index -> ({'' -> value} or {path -> value})
+        const valuesByIndexAndPath = this._sortSpecParts.map(spec => {
+            // Expand any leaf arrays that we find, and ignore those arrays
+            // themselves.  (We never sort based on an array itself.)
+            let branches = (0, minimongo_common_1.expandArraysInBranches)(spec.lookup(doc), true);
+            // If there are no values for a key (eg, key goes to an empty array),
+            // pretend we found one undefined value.
+            if (!branches.length) {
+                branches = [{ value: void 0 }];
+            }
+            const element = Object.create(null);
+            let usedPaths = false;
+            branches.forEach(branch => {
+                if (!branch.arrayIndices) {
+                    // If there are no array indices for a branch, then it must be the
+                    // only branch, because the only thing that produces multiple branches
+                    // is the use of arrays.
+                    if (branches.length > 1) {
+                        throw Error('multiple branches but no array used?');
+                    }
+                    element[''] = branch.value;
+                    return;
+                }
+                usedPaths = true;
+                const path = pathFromIndices(branch.arrayIndices);
+                if (minimongo_common_1.hasOwn.call(element, path)) {
+                    throw Error(`duplicate path: ${path}`);
+                }
+                element[path] = branch.value;
+                // If two sort fields both go into arrays, they have to go into the
+                // exact same arrays and we have to find the same paths.  This is
+                // roughly the same condition that makes MongoDB throw this strange
+                // error message.  eg, the main thing is that if sort spec is {a: 1,
+                // b:1} then a and b cannot both be arrays.
+                //
+                // (In MongoDB it seems to be OK to have {a: 1, 'a.x.y': 1} where 'a'
+                // and 'a.x.y' are both arrays, but we don't allow this for now.
+                // #NestedArraySort
+                // XXX achieve full compatibility here
+                if (knownPaths && !minimongo_common_1.hasOwn.call(knownPaths, path)) {
+                    throw Error('cannot index parallel arrays');
+                }
+            });
+            if (knownPaths) {
+                // Similarly to above, paths must match everywhere, unless this is a
+                // non-array field.
+                if (!minimongo_common_1.hasOwn.call(element, '') &&
+                    Object.keys(knownPaths).length !== Object.keys(element).length) {
+                    throw Error('cannot index parallel arrays!');
+                }
+            }
+            else if (usedPaths) {
+                knownPaths = {};
+                Object.keys(element).forEach(path => {
+                    knownPaths[path] = true;
+                });
+            }
+            return element;
+        });
+        if (!knownPaths) {
+            // Easy case: no use of arrays.
+            const soleKey = valuesByIndexAndPath.map(values => {
+                if (!minimongo_common_1.hasOwn.call(values, '')) {
+                    throw Error('no value in sole key case?');
+                }
+                return values[''];
+            });
+            cb(soleKey);
+            return;
+        }
+        Object.keys(knownPaths).forEach(path => {
+            const key = valuesByIndexAndPath.map(values => {
+                if (minimongo_common_1.hasOwn.call(values, '')) {
+                    return values[''];
+                }
+                if (!minimongo_common_1.hasOwn.call(values, path)) {
+                    throw Error('missing path?');
+                }
+                return values[path];
+            });
+            cb(key);
+        });
+    }
+    // Returns a comparator that represents the sort specification (but not
+    // including a possible geoquery distance tie-breaker).
+    _getBaseComparator() {
+        if (this._sortFunction) {
+            return this._sortFunction;
+        }
+        // If we're only sorting on geoquery distance and no specs, just say
+        // everything is equal.
+        if (!this._sortSpecParts.length) {
+            return (doc1, doc2) => 0;
+        }
+        return (doc1, doc2) => {
+            const key1 = this._getMinKeyFromDoc(doc1);
+            const key2 = this._getMinKeyFromDoc(doc2);
+            return this._compareKeys(key1, key2);
+        };
+    }
+    // Finds the minimum key from the doc, according to the sort specs.  (We say
+    // "minimum" here but this is with respect to the sort spec, so "descending"
+    // sort fields mean we're finding the max for that field.)
+    //
+    // Note that this is NOT "find the minimum value of the first field, the
+    // minimum value of the second field, etc"... it's "choose the
+    // lexicographically minimum value of the key vector, allowing only keys which
+    // you can find along the same paths".  ie, for a doc {a: [{x: 0, y: 5}, {x:
+    // 1, y: 3}]} with sort spec {'a.x': 1, 'a.y': 1}, the only keys are [0,5] and
+    // [1,3], and the minimum key is [0,5]; notably, [0,3] is NOT a key.
+    _getMinKeyFromDoc(doc) {
+        let minKey = null;
+        this._generateKeysFromDoc(doc, key => {
+            if (minKey === null) {
+                minKey = key;
+                return;
+            }
+            if (this._compareKeys(key, minKey) < 0) {
+                minKey = key;
+            }
+        });
+        return minKey;
+    }
+    _getPaths() {
+        return this._sortSpecParts.map(part => part.path);
+    }
+    // Given an index 'i', returns a comparator that compares two key arrays based
+    // on field 'i'.
+    _keyFieldComparator(i) {
+        const invert = !this._sortSpecParts[i].ascending;
+        return (key1, key2) => {
+            const compare = minimongo_common_1._f._cmp(key1[i], key2[i]);
+            return invert ? -compare : compare;
+        };
+    }
+}
+exports.default = MinimongoSorter;
+// Given an array of comparators
+// (functions (a,b)->(negative or positive or zero)), returns a single
+// comparator which uses each comparator in order and returns the first
+// non-zero value.
+function composeComparators(comparatorArray) {
+    return (a, b) => {
+        for (let i = 0; i < comparatorArray.length; ++i) {
+            const compare = comparatorArray[i](a, b);
+            if (compare !== 0) {
+                return compare;
+            }
+        }
+        return 0;
+    };
+}

package/dist/meteor/mongo/observe_driver_utils.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports._idsMatchedBySelector = exports.forEachTrigger = exports.listenAll = void 0;
+const crossbar_1 = require("../ddp/crossbar");
+// Listen for the invalidation messages that will trigger us to poll the
+// database for changes. If this selector specifies specific IDs, specify them
+// here, so that updates to different specific IDs don't cause us to poll.
+// listenCallback is the same kind of (notification, complete) callback passed
+// to InvalidationCrossbar.listen.
+function listenAll(cursorDescription, listenCallback) {
+    var listeners = [];
+    forEachTrigger(cursorDescription, function (trigger) {
+        listeners.push(crossbar_1._InvalidationCrossbar.listen(trigger, listenCallback));
+    });
+    return {
+        stop: function () {
+            for (const listener of listeners) {
+                listener.stop();
+            }
+        }
+    };
+}
+exports.listenAll = listenAll;
+function forEachTrigger(cursorDescription, triggerCallback) {
+    var key = { collection: cursorDescription.collectionName };
+    var specificIds = _idsMatchedBySelector(cursorDescription.selector);
+    if (specificIds) {
+        for (const id of specificIds) {
+            triggerCallback(Object.assign({ id: id }, key));
+        }
+        triggerCallback(Object.assign({ dropCollection: true, id: null }, key));
+    }
+    else {
+        triggerCallback(key);
+    }
+    // Everyone cares about the database being dropped.
+    triggerCallback({ dropDatabase: true });
+}
+exports.forEachTrigger = forEachTrigger;
+function _idsMatchedBySelector(selector) {
+    if (!selector) {
+        return null;
+    }
+    // Do we have an _id clause?
+    if (selector.hasOwnProperty('_id')) {
+        // Is the _id clause just an ID?
+        if (typeof selector._id === "string") {
+            return [selector._id];
+        }
+        // Is the _id clause {_id: {$in: ["x", "y", "z"]}}?
+        if (selector._id
+            && "$in" in selector._id
+            && Array.isArray(selector._id.$in)
+            && selector._id.$in.length
+            && selector._id.$in.every(id => typeof id === "string")) {
+            return selector._id.$in;
+        }
+        return null;
+    }
+    // If this is a top-level $and, and any of the clauses constrain their
+    // documents, then the whole selector is constrained by any one clause's
+    // constraint. (Well, by their intersection, but that seems unlikely.)
+    if ("$and" in selector && Array.isArray(selector.$and)) {
+        for (let i = 0; i < selector.$and.length; ++i) {
+            const subIds = _idsMatchedBySelector(selector.$and[i]);
+            if (subIds) {
+                return subIds;
+            }
+        }
+    }
+    return null;
+}
+exports._idsMatchedBySelector = _idsMatchedBySelector;