mongodb-livedata-server 0.0.4 → 0.0.6

package/meteor/mongo/minimongo_matcher.ts

@@ -1,275 +0,0 @@
-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

@@ -1,331 +0,0 @@
-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

@@ -1,79 +0,0 @@
-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;
-}