mongodb-livedata-server 0.0.1

package/meteor/mongo/minimongo_matcher.ts

@@ -0,0 +1,275 @@
+import {
+    combineImportantPathsIntoProjection,
+    compileDocumentSelector,
+    hasOwn,
+    isNumericKey,
+    isOperatorObject,
+    nothingMatcher,
+    _modify,
+    _pathsElidingNumericKeys,
+} from './minimongo_common';
+import { Filter } from 'mongodb';
+import { clone, isBinary } from '../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})) ...
+
+export class MinimongoMatcher {
+    private _paths: Record<string, any>;
+    private _hasGeoQuery: boolean;
+    private _hasWhere: boolean;
+    private _isSimple: boolean;
+    private _matchingDocument: any;
+    private _selector: Filter<any>;
+    private _docMatcher: any;
+    private _isUpdate: boolean;
+
+    constructor(selector: Filter<any>, isUpdate?: boolean) {
+        // 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: Filter<any>) {
+        // 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 || hasOwn.call(selector, '_id') && !selector._id) {
+            this._isSimple = false;
+            return nothingMatcher;
+        }
+
+        // Top level can't be an array or true or binary.
+        if (Array.isArray(selector) ||
+            isBinary(selector) ||
+            typeof selector === 'boolean') {
+            throw new Error(`Invalid selector: ${selector}`);
+        }
+
+        this._selector = clone(selector);
+
+        return 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 (isNumericKey(sel[i]) && 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 (isNumericKey(sel[i])) {
+                        // foo.4.bar selector unaffected by foo.bar modifier
+                        return false;
+                    } else if (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;
+            });
+        });
+    }
+
+    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 (!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 = clone(this.matchingDocument());
+
+        // The selector is too complex, anything can happen.
+        if (matchingDocument === null) {
+            return true;
+        }
+
+        try {
+            _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;
+    }
+
+    // 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 = _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 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;
+    }
+}
+
+function pathHasNumericKeys(path: string) {
+    return path.split('.').some(isNumericKey);
+}

package/meteor/mongo/minimongo_sorter.ts

@@ -0,0 +1,331 @@
+import {
+    combineImportantPathsIntoProjection,
+    expandArraysInBranches,
+    hasOwn,
+    makeLookupFunction,
+    _f,
+    _pathsElidingNumericKeys,
+} from './minimongo_common';
+import { MinimongoMatcher } from './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.
+
+export default class MinimongoSorter {
+    private _sortSpecParts: {ascending: boolean, path: string, lookup: Function}[];
+    private _sortFunction: (a: any, b: any) => number | null;
+    private _keyComparator: (a: any, b: any) => number;
+    private _selectorForAffectedByModifier: MinimongoMatcher;
+
+    constructor(spec) {
+        this._sortSpecParts = [];
+        this._sortFunction = null;
+
+        const addSpecPart = (path: string, ascending: boolean) => {
+            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: 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 MinimongoMatcher(selector);
+        }
+
+        this._keyComparator = composeComparators(
+            this._sortSpecParts.map((spec, i) => this._keyFieldComparator(i))
+        );
+    }
+
+    affectedByModifier(modifier) {
+        return this._selectorForAffectedByModifier.affectedByModifier(modifier);
+    }
+
+    getComparator(options?): (a: any, b: any) => number {
+        // 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 = 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 (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 && !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 (!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 (!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 (hasOwn.call(values, '')) {
+                    return values[''];
+                }
+
+                if (!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: number) {
+        const invert = !this._sortSpecParts[i].ascending;
+
+        return (key1, key2) => {
+            const compare = _f._cmp(key1[i], key2[i]);
+            return invert ? -compare : compare;
+        };
+    }
+
+    combineIntoProjection = function (projection) {
+        return combineImportantPathsIntoProjection(_pathsElidingNumericKeys(this._getPaths()), projection);
+    }
+
+}
+
+// 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/meteor/mongo/observe_driver_utils.ts

@@ -0,0 +1,79 @@
+import MongoDB from "mongodb";
+import { _InvalidationCrossbar } from "../ddp/crossbar";
+import { CursorDescription } from "./live_cursor";
+
+// 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.
+
+export function listenAll(cursorDescription: CursorDescription<any>, listenCallback: Function) {
+    var listeners = [];
+    forEachTrigger(cursorDescription, function (trigger) {
+        listeners.push(_InvalidationCrossbar.listen(trigger, listenCallback));
+    });
+
+    return {
+        stop: function () {
+            for (const listener of listeners) {
+                listener.stop();
+            }
+        }
+    };
+}
+
+export function forEachTrigger(cursorDescription: CursorDescription<any>, triggerCallback: Function) {
+    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 });
+}
+
+export function _idsMatchedBySelector(selector: MongoDB.Filter<{ _id: string }>) {
+    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;
+}