masterrecord 0.0.24 → 0.0.25

package/QueryLanguage/_Expression.js

@@ -1,322 +0,0 @@
-// TODO: EXPRESSION WILL HAVE METHODS THAT WILL CONVERT EXPRESIONS TO SYNTAX TREE
-// TODO: THEN WE WILL TURN THAT EXPRESSION SYNTEX TREE INTO SQLENGINE OBJECTS
-// TODO: THE SQL ENGINE WILL THEN CONVERT THAT TO RAW SQL
-// TODO: THEN THE RAW SQL WILL BE PUSHED TO SQL DATABASE 
-// TODO: ON RETURN THE OBJECT WILL PARSED USING THE ENTITY PARSER
-// TODO: THE ENTITY WILL THEN BE TRACKED FOR ANY CHANGES
-
-// EXAMPLE: https://www.npmjs.com/package/@rduk/expression
-// EXAMPLE : https://goranhrovat.github.io/linqify/index.html
-// LIST OF C# METHODS : https://medium.com/@aikeru/a-c-linq-to-javascript-translation-guide-6e1558fc1905
-
-
-
-
-var MATCH_EXPR_REGEX = /^([\w\d$_]+?)\s*=>((?:\{\sreturn\s)?[\s\S]*(?:\})?)/;
-const LOG_OPERATORS_REGEX = /(\|\|)|(&&)/;
-const SPLIT_GROUP_REGEX = /(^|\||&| )\(/;
-const REGEX_CACHE = {};
-
-
-// ON INIT  we convert the expression into an object literal with strings
-// then we loop through each object in the object literal.
-// we grab the value/key of the row
-// we remove the entity so that only the query is left
-// we while loop through each string broken by a DOT
-// we run string through a rule checker
-    // is it a field in the current entity
-        // if so add it to selectField
-    // is it an argument
-        // run it through the nestedQuery Instance
-    // is it a nested field
-        // if so get type collection or single
-        // create new instance of query language
-        // run it through some rule checker
-            // if its a collection the next string item should be an argument
-                // then call the nested query language instance argument.
-            // if its a single then the next must be a field of that model including another nested field
-                // if its a reguler field then add it the select nested field 
-
-function describeExpressionParts(parts, exprPartRegExp) {
-    let result = [], match, desc, fields, func, arg;
-    for (let part of parts) {
-        if (part.constructor == Array) {
-            result.push(describeExpressionParts(part, exprPartRegExp));
-        }
-        else {
-            if (part == "and" || part == "or") {
-                result.push(part);
-            }
-            else if (match = part.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);
-                }
-                desc = {
-                    field: (match[2] ? fields.slice(0, -1) : fields).join("."),
-                    func: func.toLowerCase(),
-                    arg: arg
-                };
-                result.push(desc);
-            }
-        }
-    }
-    return result;
-}
-
-function splitByLogicalOperators(str, entityRegExp) {
-    let operatorIndex, parts = [], part;
-    while ((operatorIndex = str.search(LOG_OPERATORS_REGEX)) != -1) {
-        part = str.slice(0, operatorIndex).trim();
-        // Check if this part is relevant for query -> contains entity variable
-        // -> if it do nothing with entity, it shouldn't be in query eg. 1 == 1
-        if (entityRegExp.test(part)) {
-            parts.push(part);
-        }
-        parts.push(str.charAt(operatorIndex) == "|" ? "or" : "and");
-        str = str.slice(operatorIndex + 2);
-    }
-    if (str.length > 0 && entityRegExp.test(str)) {
-        parts.push(str);
-    }
-    return parts;
-}
-
-function splitGroupsByLogicalOperators(groups, entityRegExp, nested = false) {
-    let parts = [], tmp;
-    for (let part of groups) {
-        if (part.constructor == Array) {
-            tmp = splitGroupsByLogicalOperators(part, entityRegExp, true);
-            if (tmp.length) {
-                parts.push(tmp);
-            }
-        }
-        else {
-            tmp = splitByLogicalOperators(part, entityRegExp);
-            if (tmp) {
-                parts = parts.concat(tmp);
-            }
-        }
-    }
-    // Check if there are some doubled logical operators after removing irelevant parts
-    for (let i = 0; i < parts.length; i++) {
-        if ((parts[i] == "and" || parts[i] == "or") && (parts[i + 1] == "and" || parts[i + 1] == "or")) {
-            parts.splice(i, 1);
-            i--;
-        }
-    }
-    const last = parts[parts.length - 1];
-    // Remove operators at end of group
-    if (last == "or" || last == "and") {
-        parts = parts.slice(0, -1);
-    }
-    // If it's only one part, return that part; but returned value must be always array
-    if (parts.length == 1 && (nested || parts[0].constructor == Array)) {
-        return parts[0];
-    }
-    return parts;
-}
-
-function splitByGroups(expr) {
-    const parts = [];
-    let bracketIndex, end, offset = 0, opening, closing, char;
-    let part = expr;
-    while ((bracketIndex = part.search(SPLIT_GROUP_REGEX)) != -1) {
-        // Search FIX - match symbol before bracket
-        if (bracketIndex != 0 || part.charAt(0) != "(") {
-            bracketIndex++;
-        }
-        // Count brackets -> find ending bracket
-        opening = 1;
-        closing = 0;
-        offset = bracketIndex + 1;
-        while (opening != closing && offset < part.length) {
-            char = part.charAt(offset);
-            if (char == "(") {
-                opening++;
-            }
-            else if (char == ")")
-                closing++;
-            offset++;
-        }
-        if (opening != closing) {
-            throw new Error("Expression has unclosed bracket");
-        }
-        parts.push(part.slice(0, bracketIndex).trim());
-        end = offset - 1;
-        // Find nested groups
-        parts.push(splitByGroups(part.slice(bracketIndex + 1, end).trim()));
-        part = part.slice(end + 1).trim();
-    }
-    if (parts.length == 0) {
-        parts.push(expr);
-    }
-    return parts;
-}
-
-function getEntityRegExps(entityName) {
-    let REGEXPS = REGEX_CACHE[entityName];
-    if (!REGEXPS) {
-        REGEX_CACHE[entityName] = REGEXPS = {
-            MATCH_ENTITY_REGEXP: new RegExp("(^|[^\\w\\d])" + entityName + "[ \\.\\)]"),
-            OPERATORS_REGEX: new RegExp("(?:^|[^\\w\\d])" + entityName
-                + "\\.((?:\\.?[\\w\\d_\\$]+)+)(?:\\((.*?)\\))?(?:\\s*(>|<|(?:===)|(?:!==)|(?:==)|(?:!=)|(?:<=)|(?:>=)|(?:in))\\s*(.*))?")
-        };
-    }
-    return REGEXPS;
-}
-
-function convertWhereExpr(expr) {
-	const exprs = expr.expr;
-    const { MATCH_ENTITY_REGEXP, OPERATORS_REGEX } = getEntityRegExps(expr.entity);
-    const groups = splitByGroups(exprs);
-    const parts = splitGroupsByLogicalOperators(groups, MATCH_ENTITY_REGEXP);
-    expr.desc = describeExpressionParts(parts, OPERATORS_REGEX);
-    return expr;
-}
-
-class Expression{
-
-	constructor(){
-		/**
-         * List of conditions
-         * @private
-         */
-        this.conditions = [];
-        /**
-         * List of filter arguments
-         * @private
-         */
-        this.whereArgs = [];
-	}
-
-	addExpression(expression, ...args) {
-
-		const conexpr = this.matchExpression(expression);
-		const expr = convertWhereExpr(conexpr);
-		// If some coditions already exists, add this WHERE as AND
-		if (this.conditions.length != 0) {
-			expr.desc.unshift("and");
-		}
-		this.whereArgs = this.whereArgs.concat(args);
-		this.conditions = this.conditions.concat(expr.desc);
-	}
-    
-    // adds the context to virtual obj
-    getContext(virtualObj, contexts){
-
-        // virtual model: type, field and arg
-        var build = this.buildExpObject(virtualObj.func);
-        var foundContext = false;
-        for (var context of contexts) {
-            if(context.name ===  virtualObj.name){
-                build.context = new context();
-                foundContext = true;
-            }
-        }
-
-        if(foundContext === false){
-            throw new Error(virtualObj.name + " is not a model name in dbset");
-        }
-
-        return build;
-    }
-
-    // builds an object from an expression
-    buildExpObject(stringExpression){
-        return {
-            name :stringExpression.match(new RegExp("^([^.]+)", "g"))[0],
-            func : stringExpression.replace(new RegExp("^([^.]+)", "g"), "").replace(/^\./, ""),
-            arg: "grab the inside of the name"
-        }
-    }
-
-	initExpression(expr, model, modelName) {
-	
-		const str = expr.toString();
-        var that = this;
-		if (str[str.length - 1] == "}") {
-			throw new Error("Parameter expr must be simple arrow function.")
-		}
-
-		if (str[0] === "(") {
-			throw new Error("Use arrow function without brackets around parameter.");
-		}
-
-		const match = str.match(MATCH_EXPR_REGEX);
-
-		if (!match) {
-			throw new Error("Invalid expression");
-		}
-
-		const entity = match[1];
-		let exprStr = match[2];
-
-        const fields = [];
-        const virtualFields = [];
-        const nestedFields = [];
-        // var regex = new RegExp(entity + "\\.([\\w_]+)", "g");
-        var regexString = "(?<=:\\" + entity + ")([^,}]*)";
-        var regex = new RegExp(regexString, "g");
-		exprStr.replace(regex, function (_, field) {
-
-            // remove the entity from string
-            var fieldExp = field.replace(/(\/\*[^*]*\*\/)|(\/\/[^*]*)/g, '').replace(new RegExp("^(" + entity + "\.)", "g"), "").trim();
-            var fieldObj =  that.buildExpObject(fieldExp);
-            const keys = Object.keys(model);
-            var keyNotFound = false;
-            for (const key of keys) {
-                if(fieldObj.name === model[key].name){
-                    keyNotFound = true;
-                    if(model[key].virtual === true){
-                        // check is vitual is a single or collection one to one or one to many or many to many
-                        var modelKeyType;
-                        if(model[key].hasMany !== undefined){
-                            modelKeyType = "collection";
-                        }else{
-                            modelKeyType = "single";
-                        }
-                        fieldObj.type =  modelKeyType;
-                        virtualFields.push(fieldObj);                        // we will do a left outer join
-                        
-                    }
-                    else{
-                        // if arg has no text then that means there is no nested values
-                        if(fieldObj.func === ""){
-                            if (!fields.includes(fieldObj.name)) fields.push(fieldObj.name);
-                        }else{
-                            nestedFields.push(fieldObj);
-                        }
-                        
-                    }
-                }
-            }
-            if(keyNotFound === false){
-                throw new Error(fieldObj.name + " is not apart of " + modelName);
-            }
-		});
-
-		let cachedExpr = {
-			entity: entity,
-			expr: exprStr.trim(),
-            selectFields: fields,
-            virtualFields : virtualFields,
-            nestedFields : nestedFields
-		};
-
-	
-		return cachedExpr;
-	};
-}
-module.exports = Expression;

package/QueryLanguage/_LogicalQuery.js

@@ -1,23 +0,0 @@
-
-
-var Query = require('masterrecord/QueryLanguage/_simpleQuery');
-
-class LogicalQuery {
-    constructor(context, modelName){
-        this.__model = context.__allContext[0].__name === modelName;
-        this.__query = new Query(this.__model, context);
-    }
-
-    build(tokenQuery){
-
-        // we will run code to create new instances of the of the QueryModel and procss code
-        // where(r => r.name == "richard").single().flys.distinct().toList();
-
-        // loop thourgh and call all functions to build out the query;
-        return this.__query;
-    }
-
-
-}
-
-module.exports =  LogicalQuery;

package/QueryLanguage/_OperatorList.js

@@ -1,88 +0,0 @@
-// List all operators and base them on collections and non collections
-// we can use this to validate which operators can and can't be used
- var OperatorList = {
-     where : {
-         type: "collection",
-         section: "condition",
-         returnType : "collection"
-     },
-     contains : {
-        type: "single",
-        returnType : "none"
-    },
-    skip : {
-        type: "collection",
-        returnType : "collection",
-        section: "limit"
-    },
-    take: {
-        type: "collection",
-        returnType : "collection"
-    },
-    last: {
-        type: "collection",
-        returnType : "single"
-    },
-    orderByDescending : {
-
-    },
-    orderBy : {
-
-    },
-    groupBy : {
-
-    },
-    union: {
-
-    },
-    find : {
-
-    },
-    except : {
-
-    },
-    any : {
-
-    },
-    select : {
-
-    },
-    distinct :{
-
-    },
-    count :{
-
-    },
-    average :{
-
-    },
-    sum : {
-
-    },
-    max : {
-
-    },
-    min : {
-
-    },
-    join : {
-        type: "collection",
-        returnType: "collection"
-    },
-    groupJoin :{
-
-    },
-    toArray : {
-
-    },
-    toDictionary : {
-
-    },
-    toList : {
-
-    },
-    single : {
-
-    }
-
-}