masterrecord 0.0.37 → 0.0.39

package/QueryLanguage/queryManager.js

@@ -0,0 +1,79 @@
+// ALL THIS SHOULD DO IS BUILD A SQL QUERY
+// version 1.0.1
+
+class queryManager{
+    constructor( query) {
+
+        /*
+            queryObject
+            {
+                "where": where user.id = 1
+                "raw": "select * from tablename where user.id = 2" OR false,
+                "builder": builderObject,
+                "select" : "*",
+                "from" : from tablename
+            }
+        */
+        this._query = query;
+        this._queryBuilder = query.builder;
+        this._context = query.builder.__context;
+    }
+    
+    single(){
+        var entityValue = this._context._SQLEngine.get(this._query.getScript());
+        var sing = this._queryBuilder.__execute(entityValue, this._queryBuilder);
+        return sing;
+    }
+
+    //
+    select(query){
+       // this will come after the where
+       this._query.select = "select " + query;
+       return this;
+    }
+    
+    count(){
+        // trying to match string select and relace with select Count(*);
+        var res = this._query.select.replace("select *", "select Count(*)");
+        var entityValue = this._context._SQLEngine.get(res);
+        var val = entityValue[Object.keys(entityValue)[0]];
+        return val;
+    }
+
+    toList(){
+        var entityValue = this._context._SQLEngine.all(this._query);
+        var toLi = this._queryBuilder.__executeList(entityValue, this._queryBuilder);
+        return toLi;
+    }
+
+}
+
+module.exports = queryManager;
+
+
+/*
+
+LINQ Extension Methods
+First()
+FirstOrDefault()
+SingleOrDefault()
+Count()
+Min()
+Max()
+Last()
+LastOrDefault()
+Average()
+*/
+/*
+
+LINQ Extension Methods
+First()
+FirstOrDefault()
+SingleOrDefault()
+Count()
+Min()
+Max()
+Last()
+LastOrDefault()
+Average()
+*/

package/QueryLanguage/queryMethods.js

@@ -1,5 +1,5 @@
 
-// version 0.0.7
+// version 0.0.8
 var entityTrackerModel = require('masterrecord/Entity/entityTrackerModel');
 var tools = require('masterrecord/Tools');
 var queryScript = require('masterrecord/QueryLanguage/queryScript');
@@ -54,10 +54,6 @@ class queryMethods{
         
     }
 
-    contains(){
-            // https://entityframework.net/knowledge-base/3491721/linq-to-entities---where-in-clause-in-query
-    }
-
     // do join on two tables = inner join
     _____leftJoin(){
 
@@ -137,6 +133,7 @@ class queryMethods{
                 str = str.replace("$$", item);
             }
         }
+
         this.__queryObject.where(str, this.__entity.__name);
         return this;
     }

package/QueryLanguage/queryScript.js

@@ -1,4 +1,4 @@
-// version 0.0.2
+// version 0.0.3
 
 const LOG_OPERATORS_REGEX = /(\|\|)|(&&)/;
 var tools =  require('../Tools');
@@ -63,7 +63,6 @@ class queryScript{
     }
 
     where(text, entityName){
-
         this.buildScript(text, "where", this.script, entityName);
         return this.script;
     }
@@ -85,62 +84,58 @@ class queryScript{
 
     buildScript(text, type, obj, entityName){
 
-        var groups = this.splitByFunctions(text);
-        var cachedExpr = {}; // this function will just get the high leve
-        if(groups.length > 0){
-          
-            cachedExpr.entity = this.getEntity(text);
-            
-            if(!this.isMapped(entityName, obj.entityMap)){
+        var cachedExpr = {}; // this function will just get the high level
 
-                obj.entityMap.push({
-                    name: entityName,
-                    entity : cachedExpr.entity
-                });
-            }
-            obj.entity = cachedExpr.entity
-            //tools.getRandomLetter(1)
-            cachedExpr[entityName] = this.splitGroupsByLogicalOperators(groups);
+        /// first we find all the groups in the query string
+        var querySections = this.getFunctionsInQuery(text);
 
+        // remove spaces from query and get the Entity
+        cachedExpr.entity = this.getEntity(text);
+        
 
-            // lets break the string into a list of functions
-            this.buildFields(text, cachedExpr);
+        if(!this.isMapped(entityName, obj.entityMap)){
 
-            if(type === "include"){
-                if(cachedExpr.selectFields){
-                    if(!this.isMapped(cachedExpr.selectFields[0], obj.entityMap)){
-                        obj.entityMap.push({
-                            name: tools.capitalizeFirstLetter(cachedExpr.selectFields[0]),
-                            entity : tools.getRandomLetter(1, obj.entityMap)
-                        });
-                    }
-                };
-            }
+            obj.entityMap.push({
+                name: entityName,
+                entity : cachedExpr.entity
+            });
+        }
 
-            this.describeExpressionParts(cachedExpr[entityName], cachedExpr.selectFields[0], obj.entityMap);
-            if(type === "include" || type === "and"){
-                obj[type].push(cachedExpr)
-            }
-            else{
-                obj[type] = cachedExpr;
-            }
-            obj.parentName = entityName;
-            return cachedExpr;
-            
+        // attach the entity name to the main Object
+        obj.entity = cachedExpr.entity
+
+        cachedExpr[entityName] = this.splitGroupsByLogicalOperators(querySections.query);
+        
+        // lets break the string into a list of functions
+        this.buildFields(text, cachedExpr);
+
+        if(type === "include"){
+            if(cachedExpr.selectFields){
+                if(!this.isMapped(cachedExpr.selectFields[0], obj.entityMap)){
+                    obj.entityMap.push({
+                        name: tools.capitalizeFirstLetter(cachedExpr.selectFields[0]),
+                        entity : tools.getRandomLetter(1, obj.entityMap)
+                    });
+                }
+            };
+        }
+
+        this.describeExpressionParts(cachedExpr[entityName]);
+        this.describeExpressionPartsFunctions(cachedExpr[entityName], querySections.functions);
+        if(type === "include" || type === "and"){
+            obj[type].push(cachedExpr);
         }
         else{
-            // this means cachedExpr is not formated as: a => a
-            if(type === "select"){
-                obj.select = {
-                   "selectFields": JSON.parse(text)
-                }
-                return obj.select;
-            }
-            return null;
+            obj[type] = cachedExpr;
         }
 
+        obj.parentName = entityName;
+        return cachedExpr;
     }
 
+   
+
+    // look and grab all fields
     buildFields(text, desc){
         var match = text.match(/^([\w\d$_]+?)\s*=>((?:\{\sreturn\s)?[\s\S]*(?:\})?)/);
         if(match){
@@ -171,35 +166,38 @@ class queryScript{
         + "\\.((?:\\.?[\\w\\d_\\$]+)+)(?:\\((.*?)\\))?(?:\\s*(>|<|(?:===)|(?:!==)|(?:==)|(?:!=)|(?:=)|(?:<=)|(?:>=)|(?:in))\\s*(.*))?")
     }
 
-    splitGroupsByLogicalOperators(groups, nested = false) {
+
+    splitGroupsByLogicalOperators(text) {
         let parts = {}, tmp;
-        for (let part of groups) {
+        var part = {query : text, name : "query"}
 
-                //tmp = this.splitByLogicalOperators(part.query, entityRegExp)
-                tmp = this.extractInside(part.query, part.name);
-                if(tmp){
-                    part.inside = tmp;
-                    parts[part.name] = part;
-                }
-                else{
-                    part.inside = part.query;
-                    parts[part.name] = part;
-                }
-                part.inside = part.inside.replace("&&", "and");
-                part.query = part.query.replace("&&", "and");
-                part.inside = part.inside.replace("||", "or");
-                part.query = part.query.replace("||", "or");
+        //tmp = this.splitByLogicalOperators(part.query, entityRegExp)
+        tmp = this.extractInside(part.query, part.name);
+        if(tmp){
+            part.inside = tmp;
+            parts[part.name] = part;
+        }
+        else{
+            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");
+
         return parts;
     }
 
 
-    splitByFunctions(str) {
+    // find all functions from querySections
+    getFunctionsInQuery(text) {
+
         const regex = /(?<=\.(?=[A-z]+\())([^(]+)\((.+?)\)(?!\))/g;
         let m;
         const items = [];
-        while ((m = regex.exec(str)) !== null) {
+        
+        while ((m = regex.exec(text)) !== null) {
             // This is necessary to avoid infinite loops with zero-width matches
             if (m.index === regex.lastIndex) {
                 regex.lastIndex++;
@@ -207,94 +205,171 @@ class queryScript{
             
             const [, fName, query] = m;
             items.push(
-                {name: fName, query: `${fName}(${query})`}
-            )
+                {name: fName, query: query, inside : query, parentFeild : this.getParentField(text, m[0]), input: m.input}
+            );
+
+           text = text.replace(`${fName}(${query})`, `func`);
+
+        }
+
+        //items.push({name: "NOFUNCTIONS", query: str})
+        
+        return {
+            functions: items,
+            query : text
+        };
+    }
+
+    getParentField(text, funcName){
+       var split = text.split(".");
+       for (let i = 0; i < split.length; i++) {
+
+            if(split[i].includes(funcName)){
+                return split[i -1];
+            }
         }
-        if(items.length === 0){
-            items.push({name: "NOFUNCTIONS", query: str})
+        return "";
+    }
+
+    findExpression(fieldName, expression){
+        // loop through and find expression
+        for (const key in expression) {
+
+           if(expression[key].field === fieldName){
+            return expression[key]
+           }
         }
-        return items;
     }
 
+    describeExpressionPartsFunctions(cachedExpr, functions){
+        cachedExpr.functions = [];
+        if(functions.length > 0){
+            for (let item in functions) {
+
+                var part = functions[item];
+                var partQuery = part.inside;
+                // get entity of inside function
+                var entity =  this.getEntity(partQuery);
+                
+                part.entity = entity;
+
+                // is the function name white listed
+                if(this.isFunction(part.name)){
+                    var scriptInner =  {
+                        select : false,
+                        where: false,
+                        and : [],
+                        include : [],
+                        raw: false,
+                        entity : "",
+                        entityMap : [],
+                        take : 0,
+                        skip: 0,
+                        orderBy : false,
+                        orderByDesc : false
+                    };
+                    
+                    if(part.name === "where"){
+                        // TODO: we need to Get this working 
+                        // recall to parse inner query of function that is being called 
+                        this.buildScript(part.inside, part.name, scriptInner, part.parentFeild);
+                        part.parentName = scriptInner.parentName;
+                        part.entity = scriptInner.where.entity;
+                        part.expr = scriptInner.where.expr;
+                        part.selectFields = scriptInner.where.selectFields;
+                        part[scriptInner.parentName] = scriptInner.where[scriptInner.parentName];
+                    }
+                    if(part.name === "include"){
+                        // TODO: we need to Get this working 
+                        // recall to parse inner query of function that is being called 
+                        this.buildScript(part.inside, part.name, scriptInner, part.parentFeild);
+                        part.parentName = scriptInner.parentName;
+                        part.entity = scriptInner.include.entity;
+                        part.expr = scriptInner.include.expr;
+                        part.selectFields = scriptInner.include.selectFields;
+                        part[scriptInner.parentName] = scriptInner.include[scriptInner.parentName];
+    
+                    }
+                    if(part.name === "select"){
+                        // TODO: we need to Get this working 
+                        // recall to parse inner query of function that is being called 
+                        this.buildScript(part.inside, part.name, scriptInner, part.parentFeild);
+                        part.parentName = scriptInner.parentName;
+                        part.entity = scriptInner.select.entity;
+                        part.expr = scriptInner.select.expr;
+                        part.selectFields = scriptInner.select.selectFields;
+                        part[scriptInner.parentName] = scriptInner.select[scriptInner.parentName];
+                    }
 
-    describeExpressionParts(parts, parentField, entityMap) {
-        
+                    // will search multiple values in a field
+                    if(part.name === "any"){
+                        // var members = data.memberContext.Member.where(r => r.first_name.any($$), "Rich, james, Oliver" ).toList();
+                        var expre = this.findExpression(part.parentFeild, cachedExpr.query.expressions)
+                        expre.func = "IN";
+                        expre.arg = `(${part.query})`;
+                        expre.isFunction = true;
+                    }
 
-            for (let item in parts) {
-                        let  match, fields, func, arg;
-                        var part = parts[item];
-                        part.expressions = [];
-                        var partQuery = part.inside;
-                        var entity =  this.getEntity(partQuery);
-                        var exprPartRegExp = this.OPERATORS_REGEX(entity);
-                            // check if query contains an AND.
-                           var splitByAnd = partQuery.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 = "!=";
-                                    }
-        
-                                    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;
-                                    if(this.isFunction(part.name)){
-                                        var scriptInner = {
-                                            include : [],
-                                            entityMap : entityMap
-                                        };
-                                        this.buildScript(part.inside, part.name, scriptInner, parentField, true);
-                                        parts.parentName = scriptInner.parentName;
-                                        part[scriptInner.parentName] = {};
-                                        if(part.name === "where"){
-                                            part.parentName = scriptInner.parentName;
-                                            part.entity = scriptInner.where.entity;
-                                            part.expr = scriptInner.where.expr;
-                                            part.selectFields = scriptInner.where.selectFields;
-                                            part[scriptInner.parentName] = scriptInner.where[scriptInner.parentName];
-                                        }
-                                        if(part.name === "include"){
-                                            part.parentName = scriptInner.parentName;
-                                            part.entity = scriptInner.include.entity;
-                                            part.expr = scriptInner.include.expr;
-                                            part.selectFields = scriptInner.include.selectFields;
-                                            part[scriptInner.parentName] = scriptInner.include[scriptInner.parentName];
+                    if(part.name === "like"){
+                        // var members = data.memberContext.Member.where(r => r.space_id == $$ && r.user_id != null && r.first_name.like($$),data.params.query.id, "r" ).toList();
+                        var expre = this.findExpression(part.parentFeild, cachedExpr.query.expressions)
+                        expre.func = part.name;
+                        expre.arg = part.query;
+                        expre.isFunction = true;
+                    }
+
+                }
+                else{
+                throw "Cannot have inner functions unless its a Where, Include, Select or Like caluse"
+                }  
+            }
+        }
         
-                                        }
-                                        if(part.name === "select"){
-                                            part.parentName = scriptInner.parentName;
-                                            part.entity = scriptInner.select.entity;
-                                            part.expr = scriptInner.select.expr;
-                                            part.selectFields = scriptInner.select.selectFields;
-                                            part[scriptInner.parentName] = scriptInner.select[scriptInner.parentName];
-                                        }
-                                        //part.inner = scriptInner;
-                                    }
-                                    else{
-                                        part.expressions.push({
-                                            field: fields[0],
-                                            func : func.toLowerCase(),
-                                            arg : arg
-                                        });
-                                    }
-                                }
-                           }
-                  
+    }
+
+    describeExpressionParts(parts) {
+        if(parts.query) {
+            let  match, fields, func, arg;
+            var part = {};
+            part.inside = parts.query.query;
+            part.expressions = [];
+            var partQuery = part.inside;
+            var entity =  this.getEntity(partQuery);
+            var exprPartRegExp = this.OPERATORS_REGEX(entity);
+            // check if query contains an AND.
+           var splitByAnd = partQuery.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 = "!=";
+                    }
+
+                    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;
+                
+                    part.expressions.push({
+                        field: fields[0],
+                        func : func.toLowerCase(),
+                        arg : arg
+                    });
+                    parts.query =  part;
                 }
+           }
+        }
 
         return parts;
     }
@@ -339,7 +414,7 @@ class queryScript{
     }
     
     isFunction(func){
-        var funcList = ["where", "select", "include"]
+        var funcList = [ "include", "like", "any"]
         for(var i =0; i < funcList.length; i++){
             if(funcList[i] === func){
                 return true

package/SQLLiteEngine.js

@@ -1,4 +1,4 @@
-// Version 0.0.6
+// Version 0.0.8
 var tools =  require('masterrecord/Tools');
 
 class SQLLiteEngine {
@@ -260,41 +260,48 @@ class SQLLiteEngine {
         var $that = this;
         if(whereEntity){
             var entity = this.getEntity(query.parentName, query.entityMap);
-            for (let part in whereEntity[query.parentName]) {
-                    var item = whereEntity[query.parentName][part];
-                    for (let exp in item.expressions) {
-                        var field = tools.capitalizeFirstLetter(item.expressions[exp].field);
-                        if(mainQuery[field]){
-                            if(mainQuery[field].isNavigational){
-                                entity = $that.getEntity(field, query.entityMap);
-                                field = item.fields[1];
-                            }
-                        }
-                        if(item.expressions[exp].arg === "null"){
-                            if(item.expressions[exp].func === "="){
-                                item.expressions[exp].func = "is"
-                            }
-                            if(item.expressions[exp].func === "!="){
-                                item.expressions[exp].func = "is not"
-                            }
-                        }
-                        if(strQuery === ""){
-                            if(item.expressions[exp].arg === "null"){
-                                strQuery = `WHERE ${entity}.${field}  ${item.expressions[exp].func} ${item.expressions[exp].arg}`;
-                            }else{
-                                strQuery = `WHERE ${entity}.${field}  ${item.expressions[exp].func} '${item.expressions[exp].arg}'`;
-                            }
+
+            var item = whereEntity[query.parentName].query;
+            for (let exp in item.expressions) {
+                var field = tools.capitalizeFirstLetter(item.expressions[exp].field);
+                if(mainQuery[field]){
+                    if(mainQuery[field].isNavigational){
+                        entity = $that.getEntity(field, query.entityMap);
+                        field = item.fields[1];
+                    }
+                }
+                if(item.expressions[exp].arg === "null"){
+                    if(item.expressions[exp].func === "="){
+                        item.expressions[exp].func = "is"
+                    }
+                    if(item.expressions[exp].func === "!="){
+                        item.expressions[exp].func = "is not"
+                    }
+                }
+                if(strQuery === ""){
+                    if(item.expressions[exp].arg === "null"){
+                        strQuery = `WHERE ${entity}.${field}  ${item.expressions[exp].func} ${item.expressions[exp].arg}`;
+                    }else{
+                        if(item.expressions[exp].func === "IN"){
+                            strQuery = `WHERE ${entity}.${field}  ${item.expressions[exp].func} ${item.expressions[exp].arg}`;
                         }
                         else{
-                            if(item.expressions[exp].arg === "null"){
-                                strQuery = `${strQuery} and ${entity}.${field}  ${item.expressions[exp].func} ${item.expressions[exp].arg}`;
-                            }else{
-                                strQuery = `${strQuery} and ${entity}.${field}  ${item.expressions[exp].func} '${item.expressions[exp].arg}'`;
-                            }
-                           
+                            strQuery = `WHERE ${entity}.${field}  ${item.expressions[exp].func} '${item.expressions[exp].arg}'`;
                         }
                     }
                 }
+                else{
+                    if(item.expressions[exp].arg === "null"){
+                        strQuery = `${strQuery} and ${entity}.${field}  ${item.expressions[exp].func} ${item.expressions[exp].arg}`;
+                    }else{
+                        strQuery = `${strQuery} and ${entity}.${field}  ${item.expressions[exp].func} '${item.expressions[exp].arg}'`;
+                    }
+                    
+                }
+            }
+
+            
+                
         }
         return strQuery;
     }

package/context.js

@@ -1,6 +1,6 @@
 // Version 0.0.5
 
-var modelBuilder  = require('./Entity/entityModelBuilder');
+var modelBuilder  = require('./Entity/EntityModelBuilder');
 var query = require('masterrecord/QueryLanguage/queryMethods');
 var tools =  require('./Tools');
 var SQLLiteEngine = require('masterrecord/SQLLiteEngine');

package/package.json

@@ -1,19 +1,19 @@
 {
   "name": "masterrecord",
   "dependencies": {
-    "better-sqlite3": "^8.6.0",
-    "commander": "^11.0.0",
-    "glob" : "^10.3.4",
+    "better-sqlite3": "^9.0.0",
+    "commander": "^11.1.0",
+    "glob" : "^10.3.10",
     "deep-object-diff" : "^1.1.9"
   },
-  "version": "0.0.37",
+  "version": "0.0.39",
   "description": "An Object-relational mapping for the Master framework. Master Record connects classes to relational database tables to establish a database with almost zero-configuration ",
   "homepage": "https://github.com/Tailor/MasterRecord#readme",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/Tailor/Masterrecord.git"
   },
-  "main": "Masterrecord.js",
+  "main": "MasterRecord.js",
   "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1"
   },

package/QueryLanguage/selectManager.js

@@ -1,66 +0,0 @@
-
-// // version 0.0.2
-
-// class selectManager{
-//     constructor( query) {
-
-//         /*
-//             queryObject
-//             {
-//                 "where": where user.id = 1
-//                 "raw": "select * from tablename where user.id = 2" OR false,
-//                 "builder": builderObject,
-//                 "select" : "*",
-//                 "from" : from tablename
-//             }
-//         */
-//         this._query = query;
-//         this._queryBuilder = query.builder;
-//         this._context = query.builder.__context;
-//     }
-    
-//     single(){
-//         var entityValue = this._context._SQLEngine.get(this._query.getScript());
-//         var sing = this._queryBuilder.__execute(entityValue, this._queryBuilder);
-//         return sing;
-//     }
-
-//     //
-//     select(query){
-//        // this will come after the where
-//        this._query.select = "select " + query;
-//        return this;
-//     }
-    
-//     count(){
-//         // trying to match string select and relace with select Count(*);
-//         var res = this._query.select.replace("select *", "select Count(*)");
-//         var entityValue = this._context._SQLEngine.get(res);
-//         var val = entityValue[Object.keys(entityValue)[0]];
-//         return val;
-//     }
-
-//     toList(){
-//         var entityValue = this._context._SQLEngine.all(this._query);
-//         var toLi = this._queryBuilder.__executeList(entityValue, this._queryBuilder);
-//         return toLi;
-//     }
-
-// }
-
-// module.exports = selectManager;
-
-
-/*
-
-LINQ Extension Methods
-First()
-FirstOrDefault()
-SingleOrDefault()
-Count()
-Min()
-Max()
-Last()
-LastOrDefault()
-Average()
-*/