mongodb-livedata-server 0.0.12 → 0.0.13

package/dist/meteor/mongo/minimongo_matcher.d.ts

@@ -15,7 +15,8 @@ export declare class MinimongoMatcher {
     isSimple(): boolean;
     _compileSelector(selector: Filter<any>): any;
     affectedByModifier(modifier: any): boolean;
-    canBecomeTrueByModifier: (modifier: any) => any;
+    canBecomeTrueByModifier(modifier: any): any;
+    matchingDocument(): any;
     combineIntoProjection(projection: any): {};
     _getPaths(): string[];
     _recordPathUsed(path: any): void;

package/dist/meteor/mongo/minimongo_matcher.js

@@ -23,62 +23,6 @@ const ejson_1 = require("../ejson/ejson");
 //   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).
@@ -188,6 +132,125 @@ class MinimongoMatcher {
             });
         });
     }
+    canBecomeTrueByModifier(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;
+    }
+    matchingDocument() {
+        // check if it was computed before
+        if (this._matchingDocument !== undefined) {
+            return this._matchingDocument;
+        }
+        // If the analysis of this selector is too hard for our implementation
+        // fallback to "YES"
+        let fallback = false;
+        this._matchingDocument = (0, minimongo_common_1.pathsToTree)(this._getPaths(), path => {
+            const valueSelector = this._selector[path];
+            if ((0, minimongo_common_1.isOperatorObject)(valueSelector)) {
+                // if there is a strict equality, there is a good
+                // chance we can use one of those as "matching"
+                // dummy value
+                if (valueSelector.$eq) {
+                    return valueSelector.$eq;
+                }
+                if (valueSelector.$in) {
+                    const matcher = new MinimongoMatcher({ placeholder: valueSelector });
+                    // Return anything from $in that matches the whole selector for this
+                    // path. If nothing matches, returns `undefined` as nothing can make
+                    // this selector into `true`.
+                    return valueSelector.$in.find(placeholder => matcher.documentMatches({ placeholder }).result);
+                }
+                if (onlyContainsKeys(valueSelector, ['$gt', '$gte', '$lt', '$lte'])) {
+                    let lowerBound = -Infinity;
+                    let upperBound = Infinity;
+                    ['$lte', '$lt'].forEach(op => {
+                        if (minimongo_common_1.hasOwn.call(valueSelector, op) &&
+                            valueSelector[op] < upperBound) {
+                            upperBound = valueSelector[op];
+                        }
+                    });
+                    ['$gte', '$gt'].forEach(op => {
+                        if (minimongo_common_1.hasOwn.call(valueSelector, op) &&
+                            valueSelector[op] > lowerBound) {
+                            lowerBound = valueSelector[op];
+                        }
+                    });
+                    const middle = (lowerBound + upperBound) / 2;
+                    const matcher = new MinimongoMatcher({ placeholder: valueSelector });
+                    if (!matcher.documentMatches({ placeholder: middle }).result &&
+                        (middle === lowerBound || middle === upperBound)) {
+                        fallback = true;
+                    }
+                    return middle;
+                }
+                if (onlyContainsKeys(valueSelector, ['$nin', '$ne'])) {
+                    // Since this._isSimple makes sure $nin and $ne are not combined with
+                    // objects or arrays, we can confidently return an empty object as it
+                    // never matches any scalar.
+                    return {};
+                }
+                fallback = true;
+            }
+            return this._selector[path];
+        }, x => x);
+        if (fallback) {
+            this._matchingDocument = null;
+        }
+        return this._matchingDocument;
+    }
+    ;
     // 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)
@@ -215,3 +278,6 @@ exports.MinimongoMatcher = MinimongoMatcher;
 function pathHasNumericKeys(path) {
     return path.split('.').some(minimongo_common_1.isNumericKey);
 }
+function onlyContainsKeys(obj, keys) {
+    return Object.keys(obj).every(k => keys.includes(k));
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mongodb-livedata-server",
-  "version": "0.0.12",
+  "version": "0.0.13",
   "description": "MongoDB live data server, extracted from Meteor, Fibers removed and converted to TypeScript",
   "main": "dist/livedata_server.js",
   "types": "dist/livedata_server.d.ts",