masterrecord 0.0.23 → 0.0.25

package/Entity/EntityTrackerModel.js

@@ -1,43 +1,223 @@
-class EntityTrackerModel {
-    constructor () {
-        this.__ID = Math.floor((Math.random() * 100000) + 1);;
-        this.__dirtyFields = [];
-        this.__state = "track";
-        this.__entity = null;
-        this.__name = null;
-    }
-
-    // entity states https://docs.microsoft.com/en-us/dotnet/api/system.data.entitystate?view=netframework-4.7.2
-
-    // start tracking model
-    build(modelValue, currentEntity){
-        this.__proto__ = {};
-        const modelFields = Object.entries(modelValue); /// return array of objects
-        var modelClass = this; // build entity with models
-        modelClass.__entity = currentEntity;
-        modelClass.__name = currentEntity.__name;
-
-        for (const [modelField, modelFieldValue] of modelFields) { // loop through database values
-            // set the value dynamiclly
-            if(currentEntity[modelField]){ // current entity has a value then add
-                modelClass["_" + modelField] = modelFieldValue;
-
-                // Setter
-                this.__proto__.__defineSetter__(modelField, function(value){
-                    modelClass.__state = "modified";
-                    modelClass.__dirtyFields.push(modelField);
-                    // Then it will add name to dirty fields
-                    this["_" + modelField] = value;
-                });
-
-                // Getter
-                this.__proto__.__defineGetter__(modelField, function(){
-                    return this["_" + modelField];
-                });
-            }   
-        }
-        return modelClass;
-    }
-}
-
+var tools =  require('../Tools');
+class EntityTrackerModel {
+
+
+    // entity states https://docs.microsoft.com/en-us/dotnet/api/system.data.entitystate?view=netframework-4.7.2
+
+    // start tracking model
+    build(dataModel, currentEntity, context){
+        var $that = this;
+        var modelClass = this.buildObject(); // build entity with models
+        modelClass.__proto__ = {};
+        const modelFields = Object.entries(dataModel); /// return array of objects
+        modelClass.__entity = currentEntity;
+        modelClass.__name = currentEntity.__name;
+        modelClass.__context = context;
+        this.buildRelationshipModels(modelClass, currentEntity, dataModel);
+        
+        // loop through data model fields
+        for (const [modelField, modelFieldValue] of modelFields) { 
+            
+            // set the value dynamiclly
+            if(!$that._isRelationship(currentEntity[modelField])){
+                // current entity has a value then add
+                modelClass["__proto__"]["_" + modelField] = modelFieldValue;
+
+                // Setter
+                modelClass.__defineSetter__(modelField, function(value){
+                    modelClass.__state = "modified";
+                    modelClass.__dirtyFields.push(modelField);
+                    if(typeof currentEntity[modelField].set === "function"){
+                        this["__proto__"]["_" + modelField] = currentEntity[modelField].set(value);
+                    }else{
+                        // Then it will add name to dirty fields
+                        this["__proto__"]["_" + modelField] = value;
+                    }
+                });
+
+                // Getter
+                modelClass.__defineGetter__(modelField, function(){
+                    if(typeof currentEntity[modelField].get === "function"){
+                        return currentEntity[modelField].get(this["__proto__"]["_" + modelField]);
+                    }else{
+                        return this["__proto__"]["_" + modelField];
+                    }
+                
+                });
+            }   
+        }
+        
+      
+        return modelClass;
+    }
+
+    buildObject(){
+        return {
+            __ID : Math.floor((Math.random() * 100000) + 1),
+            __dirtyFields : [],
+            __state : "track",
+            __entity : null,
+            __context : null,
+            __name : null
+        }
+    }
+
+    _isRelationship(entity){
+        if(entity){
+            if(entity.type === "hasOne" || entity.type === "hasMany" || entity.type === "belongsTo" || entity.type === "hasManyThrough"){ 
+                return true;
+            }
+            else{
+                return false;
+            }
+        }else{
+            return false;
+        }
+    }
+
+    buildRelationshipModels(modelClass, currentEntity, currentModel){
+        var $that = this;
+        // loop though current entity and add only relationship models to this list
+        const entityFields = Object.entries(currentEntity); 
+        for (const [entityField, entityFieldValue] of entityFields) { // loop through entity values
+          
+            if($that._isRelationship(currentEntity[entityField])){ 
+ 
+                // Setter
+                modelClass.__defineSetter__(entityField, function(value){
+                    this["__proto__"]["_" + entityField] = value;
+                });
+
+                // Getter
+                modelClass.__defineGetter__(entityField, function(){
+
+                    var ent = tools.findEntity(entityField, this.__context);
+                    if(!ent){
+                        var parentEntity = tools.findEntity(this.__name, this.__context);
+                        if(parentEntity){
+                            ent = tools.findEntity(parentEntity.__entity[entityField].foreignKey, this.__context);
+                            if(!ent){
+                                return  `Error - Entity ${parentEntity.__entity[entityField].foreignTable} not found. Please check your context for proper name.`
+                            }
+                        }
+                        else{
+                            return  `Error - Entity ${parentEntity} not found. Please check your context for proper name.`
+                        }
+                    }
+
+                    
+                    if(currentEntity[entityField].type === "belongsTo"){
+                        if(currentEntity[entityField].lazyLoading){
+                            var priKey = tools.getPrimaryKeyObject(this.__entity);
+                            var currentValue = this.__proto__[`_${entityField}`];
+                            if(currentValue){
+                                // CHECK to see if you got the info already
+                                if(typeof currentValue === 'object'){
+                                    currentValue = currentValue[priKey];
+                                }    
+                            }
+                            else{
+                                var idValue = currentEntity[entityField].foreignTable;
+                                currentValue = this.__proto__[`_${idValue}`];
+                            }
+
+                            //var modelValue = ent.raw(`select * from ${ent.__entity.__name} where ${priKey} = ${ currentValue }`).single();
+                            var modelValue = ent.where(`r => r. ${priKey} == ${ currentValue }`)
+                            this[entityField] = modelValue;
+                        }
+                        else{
+                            return this["__proto__"]["_" + entityField];
+                        }
+                    }
+                    else{
+                        // user.tags = gets all tags related to user
+                        // tag.users = get all users related to tags
+                        if(currentEntity[entityField].lazyLoading){
+                            var priKey = tools.getPrimaryKeyObject(this.__entity);
+                            var entityName = currentEntity[entityField].foreignTable === undefined ? entityField : currentEntity[entityField].foreignTable;
+                            var tableName = "";
+                            if(entityName){
+                                switch(currentEntity[entityField].type){
+                                    // TODO: move the SQL generation part to the SQL builder so that we can later on use many diffrent types of SQL databases. 
+                                    case "hasManyThrough" :
+                                        try{
+                                            var joiningEntity = this.__context[tools.capitalize(entityName)];
+                                            var entityFieldJoinName = currentEntity[entityField].foreignTable === undefined? entityField : currentEntity[entityField].foreignTable;
+                                            var thirdEntity = this.__context[tools.capitalize(entityFieldJoinName)];
+                                            var firstJoiningID = joiningEntity.__entity[this.__entity.__name].foreignTable;
+                                            var secondJoiningID = joiningEntity.__entity[entityField].foreignTable;
+                                            if(firstJoiningID && secondJoiningID )
+                                            {
+                                                var modelValue = ent.include(`p => p.${entityFieldJoinName}.select(j => j.${joiningEntity.__entity[this.__entity.__name].foreignKey})`).include(`p =>p.${this.__entity.__name}`).where(`r =>r.${this.__entity.__name}.${priKey} = ${this[priKey]}`).toList();
+                                                // var modelQuery = `select ${selectParameter} from ${this.__entity.__name} INNER JOIN ${entityName} ON ${this.__entity.__name}.${priKey} = ${entityName}.${firstJoiningID} INNER JOIN ${entityField} ON ${entityField}.${joinTablePriKey} = ${entityName}.${secondJoiningID} WHERE ${this.__entity.__name}.${priKey} = ${ this[priKey]}`;
+                                                // var modelValue = ent.raw(modelQuery).toList();
+                                                this[entityField] = modelValue;
+                                            }
+                                            else{
+                                                return "Joining table must declaire joining table names"
+                                            }
+                                        }
+                                        catch(error){
+                                            return error;
+                                        }
+                                    /*
+                                    select * from User 
+                                    INNER JOIN Tagging ON User.id = Tagging.user_id
+                                    INNER JOIN Tag ON Tag.id = Tagging.tag_id
+                                    WHERE Tagging.user_id = 13
+                                    */
+                                    break;
+                                    case "hasOne" : 
+                                        if(ent.__entity[this.__entity.__name]){
+                                            tableName = ent.__entity[this.__entity.__name].foreignKey;
+                                        }
+                                        else{
+                                            return `Error - Entity ${ent.__entity.__name} has no property named ${this.__entity.__name}`;
+                                        }
+
+                                        //var jj = ent.raw(`select * from ${entityName} where ${tableName} = ${ this[priKey] }`).single();
+                                        var modelValue = ent.where(`r => r.${tableName} == ${this[priKey]}`).single();
+                                        this[entityField] = modelValue;
+                                    break;
+                                    case "hasMany" : 
+                                        if(ent.__entity[this.__entity.__name]){
+                                            tableName = ent.__entity[this.__entity.__name].foreignKey;
+                                        }
+                                        else{
+                                            return  `Error - Entity ${ent.__entity.__name} has no property named ${this.__entity.__name}`;
+                                        }
+                                        //var modelValue = ent.raw(`select * from ${entityName} where ${tableName} = ${ this[priKey] }`).toList();
+                                        var modelValue = ent.where(`r => r.${tableName} == ${this[priKey]}`).toList();
+                                        this[entityField] = modelValue;
+                                    break;
+                                }
+                            }
+                            else{
+                                return  "Entity name must be defined"
+                            }
+                        }
+                        else{
+                            return this["__proto__"]["_" + entityField];
+                        }
+                    }
+                    
+                    
+                    return this["__proto__"]["_" + entityField];
+                //return console.log("make db call to get value", entityField);
+                });
+
+                if(currentEntity[entityField].type === "belongsTo"){
+                    // check if entity has a value if so then return that value
+                    if(currentModel[entityField]){
+                        modelClass[entityField] = currentModel[entityField];
+                    }
+                }
+               
+            }
+        
+        }
+    }
+
+}
+
 module.exports = EntityTrackerModel

package/InsertManager.js

@@ -0,0 +1,138 @@
+
+var tools =  require('./Tools');
+class InsertManager {
+// TODO: WE are using the relationshipTable and the object name stick to one so that hasMany doesnt have to give a name
+    constructor(sqlEngine, errorModel, allEntities ){
+        this._SQLEngine = sqlEngine;
+        this._errorModel = errorModel;
+        this._allEntities = allEntities;
+    }
+
+    init(currentModel){
+        this.runQueries(currentModel);
+    }
+
+    runQueries(currentModel){
+        var $that = this;
+        var cleanCurrentModel = tools.removePrimarykeyandVirtual(currentModel, currentModel.__entity);
+        this.validateEntity(cleanCurrentModel, currentModel, currentModel.__entity);
+        if(this._errorModel.isValid){
+            
+                var modelEntity = currentModel.__entity;
+                // TODO: if you try to add belongs to you must have a tag added first. if you dont throw error
+                currentModel = this.belongsToInsert(currentModel, modelEntity);
+                var SQL = this._SQLEngine.insert(currentModel);
+                var primaryKey = tools.getPrimaryKeyObject(currentModel.__entity);
+                // return all fields that have auto and dont have a value to the current model on insert
+                if(currentModel.__entity[primaryKey].auto === true){
+                    var getQueryModel = this._SQLEngine.get(`select * from ${currentModel.__entity.__name} where ${primaryKey} = ${ SQL.id }`);
+                    currentModel[primaryKey] = getQueryModel[primaryKey];
+                }
+
+                const modelKeys = Object.keys(currentModel);
+                // loop through model properties
+                for (const property of modelKeys) {
+                    var propertyModel = currentModel[property];
+                    var entityProperty = modelEntity[property] ? modelEntity[property] : {};
+                    if(entityProperty.type === "hasOne"){
+                        // make sure property model is an object not a primary data type like number or string
+                        if(typeof(propertyModel) === "object"){
+                            // check if model has its own entity
+                            if(modelEntity){
+                                propertyModel.__entity = tools.getEntity(property, $that._allEntities);
+                                propertyModel[currentModel.__entity.__name] = SQL.id;
+                                $that.runQueries(propertyModel);
+                            }
+                            else{
+                                throw `Relationship "${entityProperty.name}" could not be found please check if object has correct spelling or if it has been added to the context class`
+                            }
+                        }
+                    }
+                    
+                    if(entityProperty.type === "hasMany"){
+                        if(Array.isArray(propertyModel)){
+                            const propertyKeys = Object.keys(propertyModel);
+                            for (const propertykey of propertyKeys) {
+                                if(propertyModel[propertykey]){
+                                    propertyModel[propertykey].__entity = tools.getEntity(property, $that._allEntities);
+                                    propertyModel[propertykey][currentModel.__entity.__name] = SQL.id;
+                                    $that.runQueries(propertyModel[propertykey]);
+                                }
+                            }
+                        }
+                        else{
+                            throw `Relationship "${entityProperty.name}" must be an array`;
+                        }
+                    }
+
+                }
+        }
+        else{
+            var name = currentModel.__entity.__name;
+            console.log(`entity ${name} not valid`);
+        }
+    }
+
+    // will insert belongs to row first and return the id so that next call can be make correctly
+    belongsToInsert(currentModel, modelEntity){
+        var $that = this;
+        for(var entity in modelEntity) {
+            if(modelEntity[entity].type === "belongsTo"){
+                var foreignKey = modelEntity[entity].foreignKey === undefined ? modelEntity[entity].name : modelEntity[entity].foreignKey;
+                var newPropertyModel = currentModel[foreignKey];
+                // check if model is a value because if so then skip we dont need to make an ajax call
+                if(typeof newPropertyModel === 'object'){
+                    newPropertyModel.__entity = tools.getEntity(entity, $that._allEntities);
+                    var propertyCleanCurrentModel = tools.removePrimarykeyandVirtual(newPropertyModel, newPropertyModel.__entity);
+                    this.validateEntity(propertyCleanCurrentModel, newPropertyModel, newPropertyModel.__entity);
+                    var propertySQL = this._SQLEngine.insert(newPropertyModel);
+                    currentModel[foreignKey] = propertySQL.id; 
+                }
+            }
+        }
+        // todo:
+            // loop through all modelEntity and find all the belongs to
+            // if belongs to is true then make sql call to insert
+            // update the currentModel.
+        return currentModel;
+    }
+    // validate entity for nullable fields
+    validateEntity(currentModel, currentRealModel, entityModel){
+        for(var entity in entityModel) {
+            var currentEntity = entityModel[entity];
+            if (entityModel.hasOwnProperty(entity)) {
+                // check if there is a default value
+                if(currentEntity.default){
+                    if(!currentRealModel[entity]){
+                        // if its empty add the default value
+                        currentRealModel[entity] = currentEntity.default;
+                    }
+                }
+            
+                // SKIP belongs too
+                if(currentEntity.type !== "belongsTo"){
+                    // primary is always null in an insert so validation insert must be null
+                    if(currentEntity.nullable === false && !currentEntity.primary){
+                        // if it doesnt have a get method then call error
+                        if(currentEntity.get === undefined){
+                            if(currentModel[entity] === undefined || currentModel[entity] === null || currentModel[entity] === "" ){
+                                this._errorModel.isValid = false;
+                                var errorMessage = `Entity ${currentModel.__entity.__name} column ${entity} is a required Field`;
+                                this._errorModel.errors.push(errorMessage);
+                                throw errorMessage;
+                            }
+                        }
+                        else{
+                            currentRealModel[entity] = currentEntity.get(currentModel[entity]);
+                        }
+                    }
+                }
+            }
+
+        }
+    }
+    
+}
+
+
+module.exports = InsertManager;