masterrecord 0.1.4 → 0.2.0

package/QueryLanguage/queryMethods.js

@@ -1,5 +1,5 @@
 
-// version 0.0.10
+// version 0.0.14
 var entityTrackerModel = require('masterrecord/Entity/entityTrackerModel');
 var tools = require('masterrecord/Tools');
 var queryScript = require('masterrecord/QueryLanguage/queryScript');
@@ -61,48 +61,28 @@ class queryMethods{
 
     ______orderByCount(query,  ...args){
         var str = query.toString();
-        if(args){
-            for(let argument in args){
-                var item = args[argument];
-                str = str.replace("$$", item);
-            }
-        }
+        str = this.__validateAndReplacePlaceholders(str, args, 'orderByCount');
         this.__queryObject.orderByCount(str, this.__entity.__name);
         return this;
     }
 
     ______orderByCountDescending(query,  ...args){
         var str = query.toString();
-        if(args){
-            for(let argument in args){
-                var item = args[argument];
-                str = str.replace("$$", item);
-            }
-        }
+        str = this.__validateAndReplacePlaceholders(str, args, 'orderByCountDescending');
         this.__queryObject.orderByCountDesc(str, this.__entity.__name);
         return this;
     }
 
     orderBy(query,  ...args){
         var str = query.toString();
-        if(args){
-            for(let argument in args){
-                var item = args[argument];
-                str = str.replace("$$", item);
-            }
-        }
+        str = this.__validateAndReplacePlaceholders(str, args, 'orderBy');
         this.__queryObject.orderBy(str, this.__entity.__name);
         return this;
     }
 
     orderByDescending(query,  ...args){
         var str = query.toString();
-        if(args){
-            for(let argument in args){
-                var item = args[argument];
-                str = str.replace("$$", item);
-            }
-        }
+        str = this.__validateAndReplacePlaceholders(str, args, 'orderByDescending');
         this.__queryObject.orderByDesc(str, this.__entity.__name);
         return this;
     }
@@ -115,25 +95,14 @@ class queryMethods{
     /* WHERE and AND work together its a way to add to the WHERE CLAUSE DYNAMICALLY */
     and(query,  ...args){
         var str = query.toString();
-        if(args){
-            for(let argument in args){
-                var item = args[argument];
-                str = str.replace("$$", item);
-            }
-        }
+        str = this.__validateAndReplacePlaceholders(str, args, 'and');
         this.__queryObject.and(str, this.__entity.__name);
         return this;
     }
 
     where(query,  ...args){
         var str = query.toString();
-        if(args){
-            for(let argument in args){
-                var item = args[argument];
-                str = str.replace("$$", item);
-            }
-        }
-
+        str = this.__validateAndReplacePlaceholders(str, args, 'where');
         this.__queryObject.where(str, this.__entity.__name);
         return this;
     }
@@ -142,12 +111,7 @@ class queryMethods{
     //Eagerly loading
     include(query,  ...args){
         var str = query.toString();
-        if(args){
-            for(let argument in args){
-                var item = args[argument];
-                str = str.replace("$$", item);
-            }
-        }
+        str = this.__validateAndReplacePlaceholders(str, args, 'include');
         this.__queryObject.include(str, this.__entity.__name);
         return this;
     }
@@ -155,12 +119,7 @@ class queryMethods{
     // only takes a array of selected items
     select(query,  ...args){
         var str = query.toString();
-        if(args){
-            for(let argument in args){
-                var item = args[argument];
-                str = str.replace("$$", item);
-            }
-        }
+        str = this.__validateAndReplacePlaceholders(str, args, 'select');
         this.__queryObject.select(str, this.__entity.__name);
         return this;
     }
@@ -182,12 +141,7 @@ class queryMethods{
     count(query,  ...args){
         if(query){
             var str = query.toString();
-            if(args){
-                for(let argument in args){
-                    var item = args[argument];
-                    str = str.replace("$$", item);
-                }
-            }
+            str = this.__validateAndReplacePlaceholders(str, args, 'count');
             this.__queryObject.count(str, this.__entity.__name);
         }
 
@@ -208,7 +162,36 @@ class queryMethods{
         }
     }
 
+    __validateAndReplacePlaceholders(str, args, methodName){
+        // Count placeholders
+        const placeholderCount = (str.match(/\$\$/g) || []).length;
+        const providedCount = args ? args.length : 0;
+        if(placeholderCount !== providedCount){
+            const msg = `Query argument error in ${methodName}: expected ${placeholderCount} value(s) for '$$', but received ${providedCount}.`;
+            console.error(msg);
+            throw new Error(msg);
+        }
+        if(args){
+            for(let argument in args){
+                var item = args[argument];
+                if(typeof item === 'undefined'){
+                    const msg = `Query argument error in ${methodName}: placeholder value at index ${argument} is undefined.`;
+                    console.error(msg);
+                    throw new Error(msg);
+                }
+                str = str.replace("$$", item);
+            }
+        }
+        return str;
+    }
+
     single(){
+        // If no clauses were used before single(), seed defaults so SQL is valid
+        if(this.__queryObject.script.entityMap.length === 0){
+            this.__queryObject.skipClause(this.__entity.__name);
+            this.__queryObject.script.take = 1;
+        }
+
         if(this.__context.isSQLite){
             var entityValue = this.__context._SQLEngine.get(this.__queryObject.script, this.__entity, this.__context);
             var sing = this.__singleEntityBuilder(entityValue);
@@ -228,6 +211,9 @@ class queryMethods{
         if(this.__context.isSQLite){
             if(this.__queryObject.script.entityMap.length === 0){
                 this.__queryObject.skipClause( this.__entity.__name);
+                if(!this.__queryObject.script.take || this.__queryObject.script.take === 0){
+                    this.__queryObject.script.take = 1000;
+                }
             }
             var entityValue = this.__context._SQLEngine.all(this.__queryObject.script, this.__entity, this.__context);
             var toLi = this.__multipleEntityBuilder(entityValue);
@@ -238,6 +224,9 @@ class queryMethods{
         if(this.__context.isMySQL){
             if(this.__queryObject.script.entityMap.length === 0){
                 this.__queryObject.skipClause( this.__entity.__name);
+                if(!this.__queryObject.script.take || this.__queryObject.script.take === 0){
+                    this.__queryObject.script.take = 1000;
+                }
             }
             var entityValue = this.__context._SQLEngine.all(this.__queryObject.script, this.__entity, this.__context);
             var toLi = this.__multipleEntityBuilder(entityValue);
@@ -249,8 +238,6 @@ class queryMethods{
       // ------------------------------- FUNCTIONS THAT UPDATE SQL START FROM HERE  -----------------------------------------------------
     // ---------------------------------------------------------------------------------------------------------------------------------------
     add(entityValue){
-        // This will call context API to REMOVE entity to update list
-        tools.clearAllProto(entityValue);
         entityValue.__state = "insert";
         entityValue.__entity = this.__entity;
         entityValue.__context = this.__context;

package/QueryLanguage/queryScript.js

@@ -1,4 +1,4 @@
-// version 0.0.5
+// version 0.0.8
 
 const LOG_OPERATORS_REGEX = /(\|\|)|(&&)/;
 var tools =  require('../Tools');
@@ -137,6 +137,43 @@ class queryScript{
         if(type === "include" || type === "and"){
             obj[type].push(cachedExpr);
         }
+        else if(type === "where"){
+            // If where already exists, merge new expressions into existing where so multiple
+            // chained where(...) calls combine into a single WHERE clause (joined by AND).
+            if(obj.where && obj[entityName] && cachedExpr[entityName]){
+                const existingQuery = obj.where[entityName].query || {};
+                const incomingQuery = cachedExpr[entityName].query || {};
+                const existingExprs = existingQuery.expressions || [];
+                const incomingExprs = (incomingQuery.expressions || []).map(e => ({...e}));
+
+                // Avoid OR-group id collisions across separate where calls by offsetting
+                // incoming group ids by the max existing group id.
+                let maxGroup = 0;
+                for(let i = 0; i < existingExprs.length; i++){
+                    const g = existingExprs[i] && existingExprs[i].group;
+                    if(typeof g === 'number' && g > maxGroup){ maxGroup = g; }
+                }
+                for(let i = 0; i < incomingExprs.length; i++){
+                    if(typeof incomingExprs[i].group === 'number'){
+                        incomingExprs[i].group = incomingExprs[i].group + maxGroup;
+                    }
+                }
+
+                existingQuery.expressions = existingExprs.concat(incomingExprs);
+
+                // Merge selectFields for completeness (not strictly required for WHERE)
+                const existingFields = existingQuery.selectFields || [];
+                const incomingFields = incomingQuery.selectFields || [];
+                const mergedFields = existingFields.concat(incomingFields.filter(f => existingFields.indexOf(f) === -1));
+                if(mergedFields.length > 0){ existingQuery.selectFields = mergedFields; }
+
+                // Keep original obj.where; just ensure parentName is set correctly
+                obj.parentName = entityName;
+            }
+            else{
+                obj[type] = cachedExpr;
+            }
+        }
         else{
             obj[type] = cachedExpr;
         }
@@ -174,8 +211,9 @@ class queryScript{
     }
 
     OPERATORS_REGEX(entityName){
+        // Prefer longest operators first to avoid partially matching '>' in '>=' and leaving '=' in the argument
         return  new RegExp("(?:^|[^\\w\\d])" + entityName
-        + "\\.((?:\\.?[\\w\\d_\\$]+)+)(?:\\((.*?)\\))?(?:\\s*(>|<|(?:===)|(?:!==)|(?:==)|(?:!=)|(?:=)|(?:<=)|(?:>=)|(?:in))\\s*(.*))?")
+        + "\\.((?:\\.?[\\w\\d_\\$]+)+)(?:\\((.*?)\\))?(?:\\s*((?:===)|(?:!==)|(?:<=)|(?:>=)|(?:==)|(?:!=)|(?:in)|>|<|(?:=))\\s*(.*))?")
     }
 
 
@@ -193,10 +231,11 @@ class queryScript{
             part.inside = part.query;
             parts[part.name] = part;
         }
-        part.inside = part.inside.replaceAll("&&", "and");
-        part.query = part.query.replaceAll("&&", "and");
-        part.inside = part.inside.replaceAll("||", "or");
-        part.query = part.query.replaceAll("||", "or");
+        // Normalize logical operators and add spacing so we can safely split by tokens
+        part.inside = part.inside.replaceAll("&&", " and ");
+        part.query = part.query.replaceAll("&&", " and ");
+        part.inside = part.inside.replaceAll("||", " or ");
+        part.query = part.query.replaceAll("||", " or ");
 
         return parts;
     }
@@ -349,45 +388,73 @@ class queryScript{
             var entity =  this.getEntity(partQuery);
             var exprPartRegExp = this.OPERATORS_REGEX(entity);
             // check if query contains an AND.
-            var trimmedQuery = partQuery.replace(/\s/g, '');
-           var splitByAnd = trimmedQuery.split("and");
-           for (let splitAnds in splitByAnd) {
-
-                if (match = splitByAnd[splitAnds].match(exprPartRegExp)) {
-                    fields = match[1].split(".");
-                    func = (match[2] ? fields[fields.length - 1] : (match[3] || "exists"));
-                    
-                    if (func == "==" || func == "===") {
-                        func = "=";
-                    }
-                    else if (func == "!==") {
-                        func = "!=";
+            var normalized = partQuery.replace(/\s+/g, ' ').trim();
+            var splitByAnd = normalized.split(/\sand\s/);
+            let groupId = 0;
+            for (let splitAnds in splitByAnd) {
+                let token = splitByAnd[splitAnds];
+                // Split possible OR groups inside this AND segment
+                let orParts = token.split(/\sor\s/);
+                const hasOrGroup = orParts.length > 1;
+                let currentGroup = hasOrGroup ? (++groupId) : null;
+                for (let idx in orParts){
+                    let segment = orParts[idx];
+                    // strip wrapping parentheses pairs repeatedly
+                    segment = segment.trim();
+                    while(segment.startsWith('(') && segment.endsWith(')')){
+                        segment = segment.slice(1, -1).trim();
                     }
-
-                    arg = match[2] || match[4];
-                    if (arg == "true" || arg == "false") {
-                        arg = arg == "true";
+                    // detect unary negation like '!r.field'
+                    let isNegated = false;
+                    const negationMatch = segment.match(/^\s*!+\s*/);
+                    if(negationMatch){
+                        isNegated = true;
+                        segment = segment.replace(/^\s*!+\s*/, '');
                     }
-                    else if (arg && arg.charAt(0) == arg.charAt(arg.length - 1) && (arg.charAt(0) == "'" || arg.charAt(0) == '"')) {
-                        arg = arg.slice(1, -1);
+                    if (match = segment.match(exprPartRegExp)) {
+                        fields = match[1].split(".");
+                        func = (match[2] ? fields[fields.length - 1] : (match[3] || "exists"));
+                        if (func == "==" || func == "===") {
+                            func = "=";
+                        }
+                        else if (func == "!==") {
+                            func = "!=";
+                        }
+                        arg = match[2] || match[4];
+                        if (arg == "true" || arg == "false") {
+                            arg = arg == "true";
+                        }
+                        else if (arg && arg.charAt(0) == arg.charAt(arg.length - 1) && (arg.charAt(0) == "'" || arg.charAt(0) == '"')) {
+                            arg = arg.slice(1, -1);
+                        }
+                        part.entity = entity;
+                        const exprObj = {
+                            field: fields[0],
+                            func : func.toLowerCase(),
+                            arg : arg
+                        };
+                        // For bare field checks (exists) without explicit arg, carry negation forward
+                        if(exprObj.func === 'exists' && typeof exprObj.arg === 'undefined' && isNegated){
+                            exprObj.negate = true;
+                        }
+                        if(currentGroup){ exprObj.group = currentGroup; }
+                        part.expressions.push(exprObj);
+                        parts.query =  part;
                     }
-
-                    part.entity = entity;
-                
-                    part.expressions.push({
-                        field: fields[0],
-                        func : func.toLowerCase(),
-                        arg : arg
-                    });
-                    parts.query =  part;
                 }
-           }
+            }
         }
 
         return parts;
     }
 
     getEntity(str){
+        // Prefer parsing the lambda parameter (e.g., 'uc' in 'uc => uc.user_id == $$')
+        const m = str.match(/^\s*([\w\d$_]+?)\s*=>/);
+        if(m && m[1]){
+            return m[1];
+        }
+        // Fallback to previous behavior: first non-space char
         var clean = str.replace(/\s/g, '');  
         return clean.substring(0, 1);
     }