sorla-db 1.0.0 → 1.2.0

package/src/query_language/operators.js

@@ -1,289 +1,243 @@
-class operators {
-    /**
-     * Constructs the class and creates a property to store fieldname
-     */
-    constructor() {
-        this._currentField = null;
-        this._logicalOperators = ['$or', '$and', '$not', '$nor'];
-        this._comparisonOperators = ['$lt', '$lte', '$gt', '$gte', '$eq', '$ne', '$in', '$nin'];
-    }
-
-    /**
-     * Set current field
-     * @param string field
-     * @return void
-     */
-    set currentField(field) {
-        this._currentField = field;
-    }
-
-    /**
-     * Check if is any operator
-     * @param string operator
-     * @return boolean
-     */
-    isAnyOperator(operator) {
-        return this.isLogicalOperator(operator) || this.isOperator(operator);
-    }
-
-    /**
-     * check if is logical operator
-     * @param string operator
-     * @return boolean
-     */
-    isLogicalOperator(operator) {
-        return this._logicalOperators.indexOf(operator) > -1;
-    }
-
-    /**
-     * Is operators
-     * @param string operator
-     * @return boolean
-     */
-    isOperator(operator) {
-        return this._comparisonOperators.indexOf(operator) > -1;
-    }
-
-    /**
-     * Or operator
-     * @param array queries
-     * @param object doc
-     * @return array
-     */
-    get $or() {
-        return (queries, doc) => {
-            if(!Array.isArray(queries))
-                throw new Error('The $or operator must be an array');
-
-            let result = false;
-            queryLoop: for(const query of queries) {
-                for(const attr of Object.keys(query)) {
-                    if(this.isLogicalOperator(attr) && this[attr](query[attr], doc))
-                    {
-                        result = true;
-                        continue queryLoop;
-                    }
-
-                    if(this.handleComparison(attr, query[attr], doc))
-                    {
-                        result = true;
-                        continue queryLoop;
-                    }
-                }
-            }
-
-            return result;
-        };
-    }
-
-    /**
-     * And operator
-     * @param array queries
-     * @param object doc
-     * @return array
-     */
-    get $and() {
-        return (queries, doc) => {
-            if(!Array.isArray(queries))
-                throw new Error('The $and operator must be an array');
-
-            let result = true;
-            queryLoop: for(const query of queries) {
-                for(const attr of Object.keys(query)) {
-                    if(this.isLogicalOperator(attr) && !this[attr](query[attr], doc))
-                    {
-                        result = false;
-                        continue queryLoop;
-                    }
-
-                    if(!this.handleComparison(attr, query[attr], doc))
-                    {
-                        result = false;
-                        continue queryLoop;
-                    }
-                }
-            }
-
-            return result;
-        };
-    }
-
-    /**
-     * Not operator
-     * @param array queries
-     * @param object doc
-     * @return array
-     */
-    get $not() {
-        const self = this;
-        return (queries, doc) => {
-            if(typeof queries !== 'object')
-                throw new Error('The $not operator must be an object');
-
-            const handledComparison = self.handleComparison(this._currentField, queries, doc);
-            return !handledComparison;
-        };
-    }
-
-    /**
-     * Nor operator
-     * @param array queries
-     * @param object doc
-     * @return array
-     */
-    get $nor() {
-        return (queries, doc) => {
-            if(!Array.isArray(queries))
-                throw new Error('The $nor operator must be an array');
-
-            for(const query of queries) {
-                for(const attr of Object.keys(query)) {
-                    if(this.isLogicalOperator(attr) && this[attr](query[attr], doc))
-                        return false;
-
-                    if(this.handleComparison(attr, query[attr], doc))
-                        return false;
-                }
-            }
-
-            return true;
-        };
-    }
-
-    /**
-     * Not in operator
-     * @param mixed doc_value
-     * @param array queries
-     * @return boolean
-     */
-    get $nin() {
-        return (doc_value, queries) => {
-            if(!Array.isArray(queries))
-                throw new Error('The $nin operator must be an array');
-
-            return !this.$in(doc_value, queries);
-        }
-    }
-
-    /**
-     * In operator
-     * @param mixed doc_value
-     * @param array queries
-     * @return boolean
-     */
-    get $in() {
-        return (doc_value, queries) => {
-            if(!Array.isArray(queries))
-                throw new Error('The $in operator must be an array');
-
-            if(Array.isArray(doc_value))
-            {
-                for(const value of queries)
-                {
-                    if(doc_value.indexOf(value) > -1)
-                        return true;
-                }
-            }
-
-            return  queries.indexOf(doc_value) > -1;
-        }
-    }
-
-    /**
-     * less than
-     * @param mixed doc_value
-     * @param mixed query
-     * @return boolean
-     */
-    get $lt() {
-        return (doc_value, query) => {
-            return !Array.isArray(query) ? doc_value < query : false;
-        }
-    }
-
-    /**
-     * less than or equal
-     * @param mixed doc_value
-     * @param mixed query
-     * @return boolean
-     */
-    get $lte() {
-        return (doc_value, query) => {
-            return !Array.isArray(query) ? doc_value <= query : false;
-        }
-    }
-
-    /**
-     * greater than
-     * @param mixed doc_value
-     * @param mixed query
-     * @return boolean
-     */
-    get $gt() {
-        return (doc_value, query) => {
-            return !Array.isArray(query) ? doc_value > query : false;
-        }
-    }
-
-    /**
-     * greater than or equal
-     * @param mixed doc_value
-     * @param mixed query
-     * @return boolean
-     */
-    get $gte() {
-        return (doc_value, query) => {
-            return !Array.isArray(query) ? doc_value >= query : false;
-        }
-    }
-
-    /**
-     * not equal
-     * @param mixed doc_value
-     * @param mixed query
-     * @return boolean
-     */
-    get $ne() {
-        return (doc_value, query) => {
-            return !Array.isArray(query) ? doc_value !== query : false;
-        }
-    }
-
-    /**
-     * equal
-     * @param mixed doc_value
-     * @param mixed query
-     * @return boolean
-     */
-    get $eq() {
-        return (doc_value, query) => {
-            return !Array.isArray(query) ? doc_value === query : false;
-        };
-    }
-
-    /**
-     * Handling with comparison of columns
-     * @param string field
-     * @param mixed query
-     * @param object doc
-     * @return boolean
-     */
-    handleComparison(field, query, doc) {
-        if(typeof doc[field] === 'undefined' && typeof doc[this._currentField] === 'undefined')
-            return false;
-
-        if(this.isOperator(field))
-            return this[field](doc[this._currentField], query);
-
-        if(typeof query === 'object')
-        {
-            const operator = Object.keys(query)[0];
-            field = typeof field === 'undefined' ? this._currentField : field;
-            return this[operator](doc[field], query[operator]);
-        }
-
-        return this.$eq(doc[field], query);
-    }
-}
-
+class operators {
+    /**
+     * Constructs the class with the list of supported operators
+     */
+    constructor() {
+        this._logicalOperators = ['$or', '$and', '$not', '$nor'];
+        this._comparisonOperators = ['$lt', '$lte', '$gt', '$gte', '$eq', '$ne', '$in', '$nin'];
+    }
+
+    /**
+     * Check if is any operator
+     * @param string operator
+     * @return boolean
+     */
+    isAnyOperator(operator) {
+        return this.isLogicalOperator(operator) || this.isOperator(operator);
+    }
+
+    /**
+     * check if is logical operator
+     * @param string operator
+     * @return boolean
+     */
+    isLogicalOperator(operator) {
+        return this._logicalOperators.indexOf(operator) > -1;
+    }
+
+    /**
+     * Is operators
+     * @param string operator
+     * @return boolean
+     */
+    isOperator(operator) {
+        return this._comparisonOperators.indexOf(operator) > -1;
+    }
+
+    /**
+     * Checks if a document matches a query. Logical operators can be nested at any depth:
+     * {$and: [{age: {$gte: 30}}, {$or: [{name: 'X'}, {city: {$in: ['A', 'B']}}]}]}
+     * @param object doc
+     * @param object query
+     * @return boolean
+     */
+    matches(doc, query) {
+        if(query === null || typeof query !== 'object' || Array.isArray(query))
+            throw new Error('The query must be an object');
+
+        for(const key of Object.keys(query)) {
+            if(this.isLogicalOperator(key)) {
+                if(!this.matchesLogical(key, query[key], doc))
+                    return false;
+
+                continue;
+            }
+
+            if(!this.matchesCondition(doc[key], query[key]))
+                return false;
+        }
+
+        return true;
+    }
+
+    /**
+     * Logical operators: every query of $and, at least one of $or, none of $nor
+     * @param string operator
+     * @param array queries
+     * @param object doc
+     * @return boolean
+     */
+    matchesLogical(operator, queries, doc) {
+        if(operator === '$not')
+            throw new Error('The $not operator must be used inside a field condition, like {age: {$not: {$gt: 30}}}');
+
+        if(!Array.isArray(queries))
+            throw new Error(`The ${operator} operator must be an array`);
+
+        switch(operator) {
+            case '$and':
+                return queries.every(query => this.matches(doc, query));
+            case '$or':
+                return queries.some(query => this.matches(doc, query));
+            case '$nor':
+                return !queries.some(query => this.matches(doc, query));
+        }
+
+        return false;
+    }
+
+    /**
+     * Checks a field value against a condition: a plain value means equality, an object of operators
+     * must satisfy every operator ({$gte: 1, $lte: 5}), and $not inverts a condition
+     * @param mixed value
+     * @param mixed condition
+     * @return boolean
+     */
+    matchesCondition(value, condition) {
+        if(!this.isOperatorObject(condition))
+            return this.$eq(value, condition);
+
+        for(const operator of Object.keys(condition)) {
+            if(operator === '$not') {
+                if(this.matchesCondition(value, condition[operator]))
+                    return false;
+
+                continue;
+            }
+
+            if(!this.isOperator(operator))
+                throw new Error(`Unknown operator ${operator}`);
+
+            if(!this[operator](value, condition[operator]))
+                return false;
+        }
+
+        return true;
+    }
+
+    /**
+     * Whether a condition is an object made of operators, like {$gt: 5}
+     * @param mixed condition
+     * @return boolean
+     */
+    isOperatorObject(condition) {
+        if(condition === null || typeof condition !== 'object' || Array.isArray(condition))
+            return false;
+
+        const keys = Object.keys(condition);
+        return keys.length > 0 && keys.every(key => key.startsWith('$'));
+    }
+
+    /**
+     * Not in operator
+     * @param mixed doc_value
+     * @param array queries
+     * @return boolean
+     */
+    get $nin() {
+        return (doc_value, queries) => {
+            if(!Array.isArray(queries))
+                throw new Error('The $nin operator must be an array');
+
+            return !this.$in(doc_value, queries);
+        }
+    }
+
+    /**
+     * In operator
+     * @param mixed doc_value
+     * @param array queries
+     * @return boolean
+     */
+    get $in() {
+        return (doc_value, queries) => {
+            if(!Array.isArray(queries))
+                throw new Error('The $in operator must be an array');
+
+            if(Array.isArray(doc_value))
+            {
+                for(const value of queries)
+                {
+                    if(doc_value.indexOf(value) > -1)
+                        return true;
+                }
+            }
+
+            return  queries.indexOf(doc_value) > -1;
+        }
+    }
+
+    /**
+     * less than
+     * @param mixed doc_value
+     * @param mixed query
+     * @return boolean
+     */
+    get $lt() {
+        return (doc_value, query) => {
+            return !Array.isArray(query) ? doc_value < query : false;
+        }
+    }
+
+    /**
+     * less than or equal
+     * @param mixed doc_value
+     * @param mixed query
+     * @return boolean
+     */
+    get $lte() {
+        return (doc_value, query) => {
+            return !Array.isArray(query) ? doc_value <= query : false;
+        }
+    }
+
+    /**
+     * greater than
+     * @param mixed doc_value
+     * @param mixed query
+     * @return boolean
+     */
+    get $gt() {
+        return (doc_value, query) => {
+            return !Array.isArray(query) ? doc_value > query : false;
+        }
+    }
+
+    /**
+     * greater than or equal
+     * @param mixed doc_value
+     * @param mixed query
+     * @return boolean
+     */
+    get $gte() {
+        return (doc_value, query) => {
+            return !Array.isArray(query) ? doc_value >= query : false;
+        }
+    }
+
+    /**
+     * not equal
+     * @param mixed doc_value
+     * @param mixed query
+     * @return boolean
+     */
+    get $ne() {
+        return (doc_value, query) => {
+            return !Array.isArray(query) ? doc_value !== query : false;
+        }
+    }
+
+    /**
+     * equal
+     * @param mixed doc_value
+     * @param mixed query
+     * @return boolean
+     */
+    get $eq() {
+        return (doc_value, query) => {
+            return !Array.isArray(query) ? doc_value === query : false;
+        };
+    }
+}
+
 module.exports = operators;