masterrecord 0.0.24 → 0.0.25

package/Masterrecord.js

@@ -3,102 +3,123 @@
 // https://www.learnentityframeworkcore.com/dbset/deleting-data
 // version 1.0.14
 
-var modelBuilder  = require('masterrecord/Entity/EntityModelBuilder');
-var query = require('masterrecord/QueryLanguage/queryBuilder');
+var modelBuilder  = require('./Entity/EntityModelBuilder');
+var query = require('masterrecord/QueryLanguage/queryMethods');
 var tools =  require('./Tools');
-var SQLiteEngine  = require('./SQLiteEngine');
+var SQLLiteEngine = require('masterrecord/SQLLiteEngine');
+var MYSQLEngine = require('masterrecord/MYSQLEngine');
+var insertManager = require('./InsertManager');
+var deleteManager = require('./DeleteManager');
 
 class Context {
-
     _isModelValid = {
         isValid: true,
         errors: []
-    }
-    __allContexts = [];
+    };
+    __entities = [];
+    __builderEntities = [];
     __trackedEntities = [];
-    __relationshipModels = []
+    __relationshipModels = [];
 
     constructor(){
-        this._SQLEngine = null;
+        // TODO when we build the sql engine it depends on the which type.
+
+        this._SQLEngine = "";
+        this.__name = this.constructor.name;
     }
-    
-// IMPORTANT: SQLITE has no date so use text
-// MUST MAP TYPES TO INTERGER, TEXT, BLOB, REAL, NUMERIC
-    setup(rootFolderLocation, env){
-            /*
-                expected model {
-                    "type": "better-sqlite3",
-                    "connection" : "/db/",
-                    "password": "",
-                    "username": ""
-                }
-    
-        */
-        if(env.type !== undefined){
-            switch(env.type) {
-                case "better-sqlite3":
-                    // set the engine for everyone to use
-                    this._SQLEngine = new new SQLiteEngine();
-                    env.connection = rootFolderLocation + env.connection;
-                    this.db = this._SQLiteEngine.setDB(env, env.type);
-                    return this;
-                break;
-            }
+
+        /* 
+        SQLite expected model 
+        {
+            "type": "better-sqlite3",
+            "connection" : "/db/",
+            "password": "",
+            "username": ""
+        }
+    */
+    __SQLiteInit(env, sqlName){
+        try{
+            const sqlite3 = require(sqlName);
+            let DBAddress = `${env.completeConnection}${env.env}.sqlite3`;
+            var db = new sqlite3(DBAddress, env);
+            db.__name = sqlName;
+            this._SQLEngine = new SQLLiteEngine();
+            return db;
+        }
+        catch (e) {
+            console.log("error SQL", e);
         }
     }
 
-    returnCopywithoutPrimaryKeyAndVirtual(currentModel){
-        var newCurrentModel = Object.create(currentModel);
-        for(var entity in newCurrentModel.__entity) {
-            var currentEntity = newCurrentModel.__entity[entity];
-            if (newCurrentModel.__entity.hasOwnProperty(entity)) {
-                if(currentEntity.primary === true){
-                    newCurrentModel[`__primaryKey`] = newCurrentModel[entity];
-                    delete newCurrentModel[`_${entity}`];
-                }
-            }
-            if(currentEntity.virtual === true){
-                // skip it from the insert
-                delete newCurrentModel[`_${entity}`];
-            }
+    /*
+    mysql expected model
+         {
+             "type": "mysql",
+            host     : 'localhost',
+            user     : 'me',
+            password : 'secret',
+            database : 'my_db'
+          }
+          */
+    __mysqlInit(env, sqlName){
+        try{
+            const mysql = require(sqlName);
+            const connection = mysql.createConnection(env);
+            connection.connect();
+            db.__name = sqlName;
+            this._SQLEngine = new MYSQLEngine();
+            return connection;
 
         }
-        return newCurrentModel;
+        catch (e) {
+            console.log("error SQL", e);
+        }
     }
 
-    // loop through all the enitities and check if required
-    validateEntity(currentModel){
-        for(var entity in currentModel.__entity) {
-            var currentEntity = currentModel.__entity[entity];
-            if (currentModel.__entity.hasOwnProperty(entity)) {
-                // TODO: // check if types are correct
-                if(currentEntity.default){
-                    if(!currentModel[entity]){
-                        currentModel[entity] = currentEntity.default;
-                    }
-                }
-            
-                if(currentEntity.required === true){
-                    if(!currentModel[entity]){
-                        this._isModelValid.isValid = false;
-                        this._isModelValid.errors.push( `Entity ${entity} is a required Field`);
-                        console.log(`Entity ${entity} is a required Field`);
-                    }
+
+
+    __clearErrorHandler(){
+        this._isModelValid = {
+            isValid: true,
+            errors: []
+        };
+    };
+    
+    setup(options, rootFolderLocation){
+        
+        if(options !== undefined){
+            if(options.type !== undefined){
+                switch(options.type) {
+                    case "better-sqlite3":
+                        options.completeConnection = rootFolderLocation + options.connection;
+                        this.db = this.__SQLiteInit(options, options.type);
+                        this._SQLEngine.setDB(this.db, "better-sqlite3");
+                        return this;
+                    break;
+                    case "mysql":
+                        this.db = this.__mysqlInit(options, options.type);
+                        this._SQLEngine.setDB(this.db, "mysql");
+                        return this;
+                    break;
                 }
             }
-
+            else{
+                console.log("database type not defined - Master Record");
+            }
         }
+        else{
+            console.log("database information not added - Master Record");
+        }
+        
     }
 
-    dbset(model){
-        var validModel = modelBuilder.init(model);
-        validModel.__name = model.name;
-        this.__allContexts.push(validModel);
-        this.createNewInstance(validModel);
-    }
-
-    createNewInstance(validModel){
-        this[validModel.__name] = new query(validModel, this);
+    dbset(model, name){
+        var validModel = modelBuilder.create(model);
+        validModel.__name = name === undefined ? model.name : name;
+        this.__entities.push(validModel); // model object
+        var buildMod = tools.createNewInstance(validModel, query, this);
+        this.__builderEntities.push(buildMod); // query builder entites
+        this[validModel.__name] = buildMod;
     }
 
     modelState(){
@@ -106,59 +127,63 @@ class Context {
     }
 
     saveChanges(){
-
-        for (var model in this.__trackedEntities) {
-            var currentModel = this.__trackedEntities[model];
-            // validate required fields
-            this.validateEntity(currentModel);
-            if(this._isModelValid.valid === false){
-                // everything great
-                console.log(JSON.stringify(this._isModelValid.valid.errors));
-            }
-
-            try{
-                switch(currentModel.__state) {
-                    case "modified":
-                        if(currentModel.__dirtyFields.length <= 0){
-                            throw "Tracked entity modified with no values being changed";
-                        }
-                        var cleanCurrentModel = this.returnCopywithoutPrimaryKeyAndVirtual(currentModel);
-                        // build columns equal to value string 
-                        var argu = tools.buildSQLEqualTo(cleanCurrentModel);
-                        var primaryKey  = tools.getPrimaryKeyObject(cleanCurrentModel.__entity);
-                        var sqlUpdate = {tableName: cleanCurrentModel.__entity.__name, arg: argu, primaryKey : primaryKey, value : cleanCurrentModel[`__primaryKey`] };
-                        this._SQLEngine.update(sqlUpdate);
-                      // code block
-                      break;
-                    case "insert":
-                     
-                        var cleanCurrentModel = this.returnCopywithoutPrimaryKeyAndVirtual(currentModel);
-                        var insertObj =  tools.getInsertObj(cleanCurrentModel);
-                        var sqlUpdate = {tableName: cleanCurrentModel.__entity.__name, columns: insertObj.columns, values: insertObj.values };
-                        this._SQLEngine.insert(sqlUpdate);
-                      break;
-                    case "delete":
-                        var primaryKey  = tools.getPrimaryKeyObject(currentModel.__entity);
-                        var sqlUpdate = {tableName: currentModel.__entity.__name, primaryKey : primaryKey, value : currentModel[primaryKey] };
-                        this._SQLEngine.delete(sqlUpdate);
-                      break;
-                  }
+        try{
+            var tracked = this.__trackedEntities;
+            // start transaction
+            this._SQLEngine.startTransaction();
+            for (var model in tracked) {
+                var currentModel = tracked[model];
+                    switch(currentModel.__state) {
+                        case "insert": 
+                            var insert = new insertManager(this._SQLEngine, this._isModelValid, this.__entities);
+                            insert.init(currentModel);
+                            
+                        break;
+                        case "modified":
+                            if(currentModel.__dirtyFields.length > 0){
+                                var cleanCurrentModel = tools.removePrimarykeyandVirtual(currentModel, currentModel._entity);
+                                // build columns equal to value string 
+                                var argu = this._SQLEngine._buildSQLEqualTo(cleanCurrentModel);
+                                var primaryKey  = tools.getPrimaryKeyObject(cleanCurrentModel.__entity);
+                                var sqlUpdate = {tableName: cleanCurrentModel.__entity.__name, arg: argu, primaryKey : primaryKey, primaryKeyValue : cleanCurrentModel[primaryKey] };
+                                this._SQLEngine.update(sqlUpdate);
+                            }
+                            else{
+                                console.log("Tracked entity modified with no values being changed");
+                            }
+
+                          // code block
+                          break;
+                        case "delete":
+                            var deleteObject = new deleteManager(this._SQLEngine, this.__entities);
+                            deleteObject.init(currentModel);
+                            
+                          break;
+                    } 
             }
-            catch(error){
-                this.__trackedEntities = [];
-                console.log("error", error);
-            }   
+            this.__clearErrorHandler();
+            this._SQLEngine.endTransaction();
         }
-        this.__trackedEntities = [];
+        
+        catch(error){
+            this.__clearErrorHandler();
+            this._SQLEngine.errorTransaction();
+            console.log("error", error);
+            this.__clearTracked();
+            throw error;
+        }
+       
+        this.__clearTracked();
         return true;
     }
 
-    __Track(model){
+    // TODO: WHY WE HAVE DOUBLE TRACKED OBJECTS - LOOP THROUGH ALL TRACKED OBJECTS
+    __track(model){
         this.__trackedEntities.push(model);
         return model;
     }
 
-    __FindTracked(id){
+    __findTracked(id){
         if(id){
             for (var model in this.__trackedEntities) {
                 if(this.__trackedEntities[model].__ID === id){
@@ -168,7 +193,41 @@ class Context {
         }
         return null;
     }
+
+    __clearTracked(){
+        this.__trackedEntities = [];
+    }
 }
 
 
-module.exports = Context;
+module.exports = Context;
+
+/*
+
+//Create new standard
+var standard = new Standard();
+standard.StandardName = "Standard1";
+
+//create three new teachers
+var teacher1 = new Teacher();
+teacher1.TeacherName = "New Teacher1";
+
+var teacher2 = new Teacher();
+teacher2.TeacherName = "New Teacher2";
+
+var teacher3 = new Teacher();
+teacher3.TeacherName = "New Teacher3";
+
+//add teachers for new standard
+standard.Teachers.Add(teacher1);
+standard.Teachers.Add(teacher2);
+standard.Teachers.Add(teacher3);
+
+using (var dbCtx = new SchoolDBEntities())
+{
+    //add standard entity into standards entitySet
+    dbCtx.Standards.Add(standard);
+    //Save whole entity graph to the database
+    dbCtx.SaveChanges();
+}
+*/

package/Migrations/cli.js

@@ -12,7 +12,7 @@ program
   .option('-v, --version', '0.0.1') 
   .description('A ORM framework that facilitates the creation and use of business objects whose data requires persistent storage to a database');
 
-  // Instructions : to run command you must go to folder where contaxt file is located and run command with context file name.
+  // Instructions : to run command you must go to folder where context file is located and run command with context file name.
   program
   .command('enable-migrations <contextFileName>')
   .alias('am')
@@ -41,6 +41,7 @@ program
         }
   });
 
+  // Instructions : to run command you must go to folder where migration file is located.
   program
   .command('add-migration <name>')
   .alias('am')
@@ -52,7 +53,7 @@ program
         var migration = new Migration();
         var context = require(contextSnapshot.contextLocation);
         var newEntity = migration.EDMModelDiffer(contextSnapshot.schema, context);
-        if(newEntity !== -1){
+        if(newEntity.length > 0){
             var migrationDate = Date.now();
             migration.migrationCodeGenerator(name, newEntity, migrationDate);
             console.log(`migration ${name}_${migrationDate} created`);

package/Migrations/migrations.js

@@ -3,36 +3,55 @@ var fs = require('fs');
 // https://blog.tekspace.io/code-first-multiple-db-context-migration/
 
 // node masterrecord add-migration josh C:\Users\rbatista\Downloads\kollege\freshmen\app\models\context
+class Migrations{
 
+    EDMModelDiffer(snapShots, tableList){
+        new schemaList = []
+        const tableKeyList = Object.keys(tableList);
+        // loop through tables
+        for (const tableKey of tableKeyList) {
+            // check if table has already been migrated
+            var tableSnapShot = snapShots[tableKey];
+            if(tableSnapShot){
+                // check if we have the column in the sceama
+                const columnKeyList = Object.keys(tableKey);
+                // loop through tables
+                for (const columnKey of columnKeyList) {
+                    var newTable = {};
+                    if(tableSnapShot[columnKey]){
 
+                        /*
+                            id : {
+                                nullabale : true,
+                                type : string
+                            }
 
-/*
-SQLITE CREATE MIGRATIONS
-CREATE TABLE "user" (
-	"id"	INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT UNIQUE,
-	"auth_id"	INTEGER NOT NULL,
-	"view_counter"	INTEGER NOT NULL DEFAULT 0,
-	"background_image_id"	INTEGER NOT NULL,
-	"profile_image_id"	INTEGER NOT NULL,
-	"full_name"	TEXT NOT NULL,
-	"languages"	TEXT,
-	"profile_email"	TEXT,
-	"phone_number"	TEXT,
-	"birthmonth"	TEXT,
-	"birthday"	TEXT,
-	"created_at"	TEXT,
-	"updated_at"	TEXT
-);
-
-*/
-
-class Migrations{
-    // SQL Lite doesnt have a date so please use TEXT fields;
-
-    EDMModelDiffer(snapShot, contextModel){
+                            id : {
+                                nullabale : true,
+                                type : int,
+                                unique : true
+                            }
+                        
+                        */
+                        // if we then check if we have all the same types
+                        // loop through schema list
+                        // check if we have the same in the context
+                        // if the same then check if if value is diffrent
+                        // then delete from context
+                        // after loop complete wahtever left in conext just push to object
+                    }
+                    else{
+                        // if we dont have it then add it to the
+                        newTable[columnKey] = tableKey[columnKey];
+                        schemaList.push(newTable);
+                    }  
+                }
+            }else{
+                schemaList.push(contextKeys[key]);
+            }
             
-        // do a diff and return only diff fields
-        // if table doesnt exist then add a create database object.
+           
+        }
     }
 
     migrationCodeGenerator(name, column, migrationDate){

package/QueryLanguage/queryManager.js

@@ -0,0 +1,66 @@
+// 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()
+*/