masterrecord 0.0.24 → 0.0.26

package/DeleteManager.js

@@ -0,0 +1,51 @@
+var tools =  require('./Tools');
+
+class DeleteManager{
+    constructor(sqlEngine, entities){
+        this._SQLEngine = sqlEngine;
+        this._allEntities = entities;
+    }
+
+    init(currentModel){
+        var $that = this;
+        try{
+           this.cascadeDelete(currentModel);
+        }
+        catch(error){
+            throw error;
+        }
+    }
+
+    cascadeDelete(currentModel){
+        var $that = this;
+        if(!Array.isArray(currentModel)){
+            const entityKeys = Object.keys(currentModel.__entity);
+            // loop though all entity properties
+            for (const property of entityKeys) {
+                // cascade delete
+                if(currentModel.__entity[property].type === "hasOne" || currentModel.__entity[property].type === "hasMany"){
+                    $that.cascadeDelete( currentModel[property]);
+                }
+            }
+            this._SQLEngine.delete(currentModel);
+        }
+        else{
+
+            for(let i = 0 ; i < currentModel.length; i++) {
+                const entityKeys = Object.keys(currentModel[i].__entity);
+                // loop though all entity properties
+                for (const property of entityKeys) {
+                    // cascade delete
+                    if(currentModel[i].__entity[property].type === "hasOne" || currentModel[i].__entity[property].type === "hasMany"){
+                        $that.cascadeDelete( currentModel[i][property]);
+                    }
+                }
+                this._SQLEngine.delete(currentModel[i]);
+            }
+        }
+        
+
+    }
+}
+
+module.exports = DeleteManager;

package/Entity/EntityModel.js

@@ -16,23 +16,26 @@
 :timestamp
 
 */
-// version 1.0.15
 
+// version 1.0.16
 class EntityModel {
     
-    constructor(){
+    constructor(name){
         this.obj = {
+            name: name,
             type: null,
             primary : null,
             default : null,
             virtual : null,
-            belongsTo : null,
-            get : null,
             foreignKey : null,
             maxLength : null,
-            nullable : false, // no
-            unique : null,
-            autoIncrement : false
+            nullable : true, // no
+            unique : false,
+            auto : false,
+            cascadeOnDelete : true,
+            lazyLoading : true,
+            isNavigational : false
+            
         }
     }
 
@@ -51,17 +54,33 @@ class EntityModel {
         return this;
     }
 
+    boolean(){
+        this.obj.type = "boolean";
+        return this;
+    }
+
     maxLength(amount){
         this.obj.maxLength = amount;
         return this;
     }
+
+    // will stop cascade delete which means it will stop not auto delete relationship
+    stopCascadeOnDelete(){
+        this.obj.cascadeOnDelete = false;
+        return this;
+    }
     
     // is this obj a primary key
     primary(){
         this.obj.primary = true;
         this.obj.nullable = false;
         this.obj.unique = true;
-        this.obj.autoIncrement = true;
+        return this;
+    }
+    
+    // allows ablity to get back primaryKey on insert automaticlly return on insert
+    auto(){
+        this.obj.auto = true;
         return this;
     }
 
@@ -71,10 +90,15 @@ class EntityModel {
         return this;
     }
 
-    // get(func){
-    //     this.obj.get = func;
-    //     return this;
-    // }
+    get(func){
+        this.obj.get = func;
+        return this;
+    }
+
+    set(func){
+        this.obj.set = func;
+        return this;
+    }
 
     unique(){
         this.obj.unique = true; // yes
@@ -82,11 +106,7 @@ class EntityModel {
 
     }
 
-    autoIncrement(){
-        this.obj.autoIncrement = true;
-        return this;
-    }
-
+    // this means that it can be an empty field
     nullable(){
         this.obj.nullable = true; // yes
         return this; 
@@ -97,33 +117,77 @@ class EntityModel {
         return this; 
     }
 
-    virtual(tableName){
+    //allows you to stop lazy loading because lazy loading is added by default
+    lazyLoadingOff(){
+        this.obj.lazyLoading = false;
+        return this;
+    }
+
+    // allows you to add a virtual object that will skipped from being used as sql objects
+    virtual(){
         this.obj.virtual = true;
-        if(tableName){
-            this.obj.hasOne = tableName;
+        return this;
+    }
+
+    hasMany(foreignTable, foreignKey){
+        if(foreignKey === undefined){
+            foreignKey = `${this.obj.name.toLowerCase()}_id`;
         }
+        this.obj.type = "hasMany";
+        this.obj.foreignTable = foreignTable;
+        this.obj.foreignKey = foreignKey;
+        this.obj.isNavigational = true;
         return this;
     }
 
-    hasMany(name){
-        this.obj.hasMany = name;
+    hasOne(foreignTable, foreignKey){
+        if(foreignKey === undefined){
+            foreignKey = `${this.obj.name.toLowerCase()}_id`;
+        }
+        this.obj.type = "hasOne";
+        this.obj.foreignTable = foreignTable;
+        this.obj.foreignKey = foreignKey;
+        this.obj.isNavigational = true;
         return this;
     }
 
-    hasOne(tableName){
-        this.obj.hasOne = tableName;
+// will do a inner join with foreignKey 
+    //hasManyThrough("Tagging", "tag_id") ----- if foreignKey is not provided use the name of the object_id
+    hasManyThrough(foreignTable,  foreignKey ){
+        if(foreignKey === undefined){
+            foreignKey = `${this.obj.name.toLowerCase()}_id`;
+        }
+        this.obj.type = "hasManyThrough";
+        this.obj.foreignTable = foreignTable;// if joinKey is undefined then use name of object. 
+        this.obj.foreignKey = foreignKey; // Foreign Key table
+        this.obj.isNavigational = true;
         return this;
     }
-    
-    belongsTo(tableName){
-        this.obj.foreignKey = tableName;
+
+    // will get info
+    belongsTo(foreignTable, foreignKey){
+
+        if(foreignKey === undefined){
+            foreignKey = `${foreignTable.toLowerCase()}_id`;
+        }
+        // will use table name to find forien key
+        this.obj.type = "belongsTo";
+        this.obj.foreignTable = foreignTable; // this is the table name of the current table if diffrent from the object name
+        this.obj.foreignKey = foreignKey; // this is the table name of the joining table
+        this.obj.nullable = false; // this means it cannot be null
         return this
     }
 
-    hasForeignKey(tableName){
-        this.obj.foreignKey = tableName;
-        return this;
+    foreignKey(foreignKey){
+        this.obj.foreignKey = foreignKey;
+        this.obj.nullable = false;
+        return this
     }
 
+    foreignTable(foreignTable){
+        this.obj.foreignTable = foreignTable;
+        this.obj.nullable = false;
+        return this
+    }
 }
 module.exports = EntityModel;

package/Entity/EntityModelBuilder.js

@@ -3,7 +3,10 @@ var modelDB  = require('./EntityModel');
 // creates new instance if entity model and calls inner functions to build out a valid entity
 class EntityModelBuilder {
 
-    static init(model){
+    static create(model){
+        if(model.name === undefined){
+            throw "dbset model declaired incorrectly. Check you dbset models for code errors."
+        }
         var mod = new model(); //create new instance of Entity Model
         var obj = {};
         var methodNamesArray = Object.getOwnPropertyNames( mod.__proto__ );
@@ -14,7 +17,7 @@ class EntityModelBuilder {
         }
         // loop through all method names in the entity model
         for (var i = 0; i < methodNamesArray.length; i++) {
-            let MDB = new modelDB(); // create a new instance of entity Model class
+            let MDB = new modelDB(model.name); // create a new instance of entity Model class
             mod[methodNamesArray[i]](MDB);
             this.cleanNull(MDB.obj); // remove objects that are null or undefined
             if(Object.keys(MDB.obj).length === 0){
@@ -28,37 +31,12 @@ class EntityModelBuilder {
 
     static cleanNull(obj) {
         for (var propName in obj) { 
-          if (obj[propName]) {
+          if (obj[propName] === null) {
             delete obj[propName];
           }
         }
     }
 
-    static selectColumnQuery(objectLiteral){
-        var arr = "";
-        for(var keys = Object.keys(model), i = 0, end = keys.length; i < end; i++) {
-            var key = keys[i], value = model[key];
-            if(value.virtual === undefined){
-                arr += key + ",";
-            }
-        };
-        let cleaned = arr.substring(0,  arr.length - 1);
-        return cleaned;
-    }
-
-    // who calls this? What does this do?
-    static callAllGets(data, model){
-        console.log("callAllGets");
-        for(var keys = Object.keys(model), i = 0, end = keys.length; i < end; i++) {
-            var key = keys[i], value = model[key];
-            if(value.get){
-                data[key] = value.get(data);
-            }
-        };
-    
-        return data;
-    }
-
 }
 
 module.exports = EntityModelBuilder;

package/Entity/EntityTrackerModel.js

@@ -1,43 +1,223 @@
+var tools =  require('../Tools');
 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
+    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;
-
-        for (const [modelField, modelFieldValue] of modelFields) { // loop through database values
+        modelClass.__context = context;
+        this.buildRelationshipModels(modelClass, currentEntity, dataModel);
+        
+        // loop through data model fields
+        for (const [modelField, modelFieldValue] of modelFields) { 
+            
             // set the value dynamiclly
-            if(currentEntity[modelField]){ // current entity has a value then add
-                modelClass["_" + modelField] = modelFieldValue;
+            if(!$that._isRelationship(currentEntity[modelField])){
+                // current entity has a value then add
+                modelClass["__proto__"]["_" + modelField] = modelFieldValue;
 
                 // Setter
-                this.__proto__.__defineSetter__(modelField, function(value){
+                modelClass.__defineSetter__(modelField, function(value){
                     modelClass.__state = "modified";
                     modelClass.__dirtyFields.push(modelField);
-                    // Then it will add name to dirty fields
-                    this["_" + modelField] = value;
+                    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
-                this.__proto__.__defineGetter__(modelField, function(){
-                    return this["_" + modelField];
+                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