masterrecord 0.0.23 → 0.0.25

package/Masterrecord.js

@@ -1,179 +1,233 @@
-
-// https://github.com/kriasoft/node-sqlite
-// https://www.learnentityframeworkcore.com/dbset/deleting-data
-// version 1.0.14
-
-var modelBuilder  = require('masterrecord/Entity/EntityModelBuilder');
-var query = require('masterrecord/QueryLanguage/queryBuilder');
-var tools =  require('./Tools');
-var SQLEngine  = require('./SQLEngine');
-
-class Context {
-
-    _isModelValid = {
-        isValid: true,
-        errors: []
-    }
-    __allContexts = [];
-    __trackedEntities = [];
-    __relationshipModels = []
-
-    constructor(){
-        this._SQLEngine = new SQLEngine();
-    }
-
-    __SQLiteInit(env, sqlName){
-        const sqlite3 = require(sqlName);
-        let DBAddress = `${env.connection}${env.env}.sqlite3`;
-        var db = new sqlite3(DBAddress, env);
-        db.__name = sqlName;
-        return db;
-    }
-
-    /*
-    expected model {
-        "type": "better-sqlite3",
-        "connection" : "/db/",
-        "password": "",
-        "username": ""
-    }
-    
-    */
-    setup(rootFolderLocation, env){
-        if(env.type !== undefined){
-            switch(env.type) {
-                case "better-sqlite3":
-                    env.connection = rootFolderLocation + env.connection;
-                    this.db = this.__SQLiteInit(env, env.type);
-                    this._SQLEngine.setDB(this.db);
-                    return this;
-                break;
-            }
-        }
-    }
-
-    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}`];
-            }
-
-        }
-        return newCurrentModel;
-    }
-
-    // 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`);
-                    }
-                }
-            }
-
-        }
-    }
-
-    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);
-    }
-
-    modelState(){
-        return this._isModelValid;
-    }
-
-    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;
-                  }
-            }
-            catch(error){
-                this.__trackedEntities = [];
-                console.log("error", error);
-            }   
-        }
-        this.__trackedEntities = [];
-        return true;
-    }
-
-    __Track(model){
-        this.__trackedEntities.push(model);
-        return model;
-    }
-
-    __FindTracked(id){
-        if(id){
-            for (var model in this.__trackedEntities) {
-                if(this.__trackedEntities[model].__ID === id){
-                    return this.__trackedEntities[model];
-                }
-            }
-        }
-        return null;
-    }
-}
-
-
-module.exports = Context;
+
+// https://github.com/kriasoft/node-sqlite
+// https://www.learnentityframeworkcore.com/dbset/deleting-data
+// version 1.0.14
+
+var modelBuilder  = require('./Entity/EntityModelBuilder');
+var query = require('masterrecord/QueryLanguage/queryMethods');
+var tools =  require('./Tools');
+var SQLLiteEngine = require('masterrecord/SQLLiteEngine');
+var MYSQLEngine = require('masterrecord/MYSQLEngine');
+var insertManager = require('./InsertManager');
+var deleteManager = require('./DeleteManager');
+
+class Context {
+    _isModelValid = {
+        isValid: true,
+        errors: []
+    };
+    __entities = [];
+    __builderEntities = [];
+    __trackedEntities = [];
+    __relationshipModels = [];
+
+    constructor(){
+        // TODO when we build the sql engine it depends on the which type.
+
+        this._SQLEngine = "";
+        this.__name = this.constructor.name;
+    }
+
+        /* 
+        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);
+        }
+    }
+
+    /*
+    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;
+
+        }
+        catch (e) {
+            console.log("error SQL", e);
+        }
+    }
+
+
+
+    __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, 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(){
+        return this._isModelValid;
+    }
+
+    saveChanges(){
+        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;
+                    } 
+            }
+            this.__clearErrorHandler();
+            this._SQLEngine.endTransaction();
+        }
+        
+        catch(error){
+            this.__clearErrorHandler();
+            this._SQLEngine.errorTransaction();
+            console.log("error", error);
+            this.__clearTracked();
+            throw error;
+        }
+       
+        this.__clearTracked();
+        return true;
+    }
+
+    // TODO: WHY WE HAVE DOUBLE TRACKED OBJECTS - LOOP THROUGH ALL TRACKED OBJECTS
+    __track(model){
+        this.__trackedEntities.push(model);
+        return model;
+    }
+
+    __findTracked(id){
+        if(id){
+            for (var model in this.__trackedEntities) {
+                if(this.__trackedEntities[model].__ID === id){
+                    return this.__trackedEntities[model];
+                }
+            }
+        }
+        return null;
+    }
+
+    __clearTracked(){
+        this.__trackedEntities = [];
+    }
+}
+
+
+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

@@ -1,106 +1,107 @@
-#!/usr/bin/env node
-  // https://docs.microsoft.com/en-us/ef/ef6/modeling/code-first/migrations/
-const program = require('commander');
-let fs = require('fs');
-let path = require('path');
-var Migration = require('./migrations');
-
-const [,, ...args] = process.argv
-
-program
-  .version('0.0.1')
-  .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.
-  program
-  .command('enable-migrations <contextFileName>')
-  .alias('am')
-  .description('Enables the migration in your project by creating a Configuration class called ContextModelSnapShot.json')
-  .action(function(contextFileName){
-        // location of folder where command is being executed..
-        var executedLocation = process.cwd();
-        // go back 1 folder level
-        let previousFolder = path.join(executedLocation, '../');
-        var migrationsDirectory = `${previousFolder}/Migrations`;
-        if (!fs.existsSync(migrationsDirectory)){
-            fs.mkdirSync(migrationsDirectory);
-        }
-
-        var content = {
-            contextLocation: `${executedLocation}/${contextFileName}.js`,
-            migrationLocation: `${executedLocation}/Migrations`,
-            schema : {}
-        };
-        const jsonContent = JSON.stringify(content, null, 2);
-        try{
-          // will replace the whole file if it exist
-            fs.writeFileSync(`${migrationsDirectory}/ContextSnapShot.json`, jsonContent);
-        }catch (e){
-            console.log("Cannot write file ", e);
-        }
-  });
-
-  program
-  .command('add-migration <name>')
-  .alias('am')
-  .description('Creates a new migration class')
-  .action(function(name){
-
-      try{
-        var contextSnapshot = fs.readFileSync(`./ContextSnapShot.json`, 'utf8');
-        var migration = new Migration();
-        var context = require(contextSnapshot.contextLocation);
-        var newEntity = migration.EDMModelDiffer(contextSnapshot.schema, context);
-        if(newEntity !== -1){
-            var migrationDate = Date.now();
-            migration.migrationCodeGenerator(name, newEntity, migrationDate);
-            console.log(`migration ${name}_${migrationDate} created`);
-        }
-      }catch (e){
-          console.log("Cannot read or find file ", e);
-      }
-
-  });
-
- // will use the database settings to call and get the schema_migration table
- // we will get the list of all migrations that have been ran
- // we will compare that list with the folder of migrations to see if we ran everything 
- // the migrations we missed we will call the up method
- // the up method will run the create database functions
-// then update the database.js schema
-
- program
-  .command('update-database <databaseSettingLocation> <migrationFolderLocation> ')
-  .alias('ud')
-  .description('Apply pending migrations to database')
-  .action(function(cmd){
-      var dir = process.cwd();
-      console.log("starting server");
-      require(dir + '/server.js');
-    //return "node c:\node\server.js"
-  });
-
- // we will find the migration folder inside the nearest app folder if no migration folder is location is added
-  program
-  .command('remove-migration <name> <migrationFolderLocation>')
-  .alias('rm')
-  .description('Removes the last migration that has not been applied')
-  .action(function(name){
-    // find migration file using name and delete it.
-  });
-
-
- // we will find the migration folder inside the nearest app folder if no migration folder is location is added
-  program
-  .command('revert-migration <name> <migrationFolderLocation>')
-  .alias('rm')
-  .description('Reverts back to the last migration with given name')
-  .action(function(cmd){
-      var dir = process.cwd();
-      console.log("starting server");
-      require(dir + '/server.js');
-    //return "node c:\node\server.js"
-  });
-
+#!/usr/bin/env node
+  // https://docs.microsoft.com/en-us/ef/ef6/modeling/code-first/migrations/
+const program = require('commander');
+let fs = require('fs');
+let path = require('path');
+var Migration = require('./migrations');
+
+const [,, ...args] = process.argv
+
+program
+  .version('0.0.1')
+  .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 context file is located and run command with context file name.
+  program
+  .command('enable-migrations <contextFileName>')
+  .alias('am')
+  .description('Enables the migration in your project by creating a Configuration class called ContextModelSnapShot.json')
+  .action(function(contextFileName){
+        // location of folder where command is being executed..
+        var executedLocation = process.cwd();
+        // go back 1 folder level
+        let previousFolder = path.join(executedLocation, '../');
+        var migrationsDirectory = `${previousFolder}/Migrations`;
+        if (!fs.existsSync(migrationsDirectory)){
+            fs.mkdirSync(migrationsDirectory);
+        }
+
+        var content = {
+            contextLocation: `${executedLocation}/${contextFileName}.js`,
+            migrationLocation: `${executedLocation}/Migrations`,
+            schema : {}
+        };
+        const jsonContent = JSON.stringify(content, null, 2);
+        try{
+          // will replace the whole file if it exist
+            fs.writeFileSync(`${migrationsDirectory}/ContextSnapShot.json`, jsonContent);
+        }catch (e){
+            console.log("Cannot write file ", e);
+        }
+  });
+
+  // Instructions : to run command you must go to folder where migration file is located.
+  program
+  .command('add-migration <name>')
+  .alias('am')
+  .description('Creates a new migration class')
+  .action(function(name){
+
+      try{
+        var contextSnapshot = fs.readFileSync(`./ContextSnapShot.json`, 'utf8');
+        var migration = new Migration();
+        var context = require(contextSnapshot.contextLocation);
+        var newEntity = migration.EDMModelDiffer(contextSnapshot.schema, context);
+        if(newEntity.length > 0){
+            var migrationDate = Date.now();
+            migration.migrationCodeGenerator(name, newEntity, migrationDate);
+            console.log(`migration ${name}_${migrationDate} created`);
+        }
+      }catch (e){
+          console.log("Cannot read or find file ", e);
+      }
+
+  });
+
+ // will use the database settings to call and get the schema_migration table
+ // we will get the list of all migrations that have been ran
+ // we will compare that list with the folder of migrations to see if we ran everything 
+ // the migrations we missed we will call the up method
+ // the up method will run the create database functions
+// then update the database.js schema
+
+ program
+  .command('update-database <databaseSettingLocation> <migrationFolderLocation> ')
+  .alias('ud')
+  .description('Apply pending migrations to database')
+  .action(function(cmd){
+      var dir = process.cwd();
+      console.log("starting server");
+      require(dir + '/server.js');
+    //return "node c:\node\server.js"
+  });
+
+ // we will find the migration folder inside the nearest app folder if no migration folder is location is added
+  program
+  .command('remove-migration <name> <migrationFolderLocation>')
+  .alias('rm')
+  .description('Removes the last migration that has not been applied')
+  .action(function(name){
+    // find migration file using name and delete it.
+  });
+
+
+ // we will find the migration folder inside the nearest app folder if no migration folder is location is added
+  program
+  .command('revert-migration <name> <migrationFolderLocation>')
+  .alias('rm')
+  .description('Reverts back to the last migration with given name')
+  .action(function(cmd){
+      var dir = process.cwd();
+      console.log("starting server");
+      require(dir + '/server.js');
+    //return "node c:\node\server.js"
+  });
+
 program.parse(process.argv);