masterrecord 0.0.47 → 0.0.49

package/Migrations/migrations.js

@@ -76,7 +76,10 @@ class Migrations{
     }
 
     #findUpdatedColumns(tables){
+
+
         tables.forEach(function (item, index) {
+           
             var UD = diff.updatedDiff(item.old, item.new);
             const isEmpty = Object.keys(UD).length === 0;
             if(!isEmpty){
@@ -111,8 +114,15 @@ class Migrations{
                             });
 
                             if(columnNotFound === false){
-                                // this means it did not find the column 
-                                item.newColumns.push(value);
+                                // this means it did not find the column
+                                
+                                if(item.new[key].type !== "hasOne" && item.new[key].type !== "hasMany" && item.new[key].type !== "hasManyThrough"){
+                                    // if you have to create a new table no need to create the columns
+                                    if(item.newTables.length === 0){
+                                        item.newColumns.push(value);
+                                    }
+                                
+                                }
                             }
                         }
                         
@@ -142,7 +152,9 @@ class Migrations{
 
     // build table to build new migration snapshot
     #buildMigrationObject(oldSchema, newSchema){
+
         var tables = this.#organizeSchemaByTables(oldSchema, newSchema);
+        
         tables = this.#findNewTables(tables);
         tables = this.#findNewColumns(tables);
         tables = this.#findDeletedColumns(tables);
@@ -163,6 +175,30 @@ class Migrations{
             }
     }
 
+    // remove hasMany and hasOne and hasManyThrough
+    cleanEntities(entities){
+        var newEntity = [];
+        for (let i = 0; i < entities.length; i++) {
+            var entity = entities[i];
+            var newObj = {}
+
+            for (let key in entity) {
+                if (entity.hasOwnProperty(key)) {
+              
+                    if(entity[key].type !== "hasOne" && entity[key].type  !== "hasMany" && entity[key].type  !== "hasManyThrough"){
+                        // if(entity[key].relationshipType == "belongsTo" ){
+                        //     entity[key].name = entity[key].foreignKey;
+                        // }
+                        newObj[key] = entity[key];
+                    }
+                }
+            }
+            newEntity.push(newObj);
+        }
+
+        return newEntity;
+    }
+
     createSnapShot(snap){
         
         var dbFolder = `${snap.executedLocation}/db`;
@@ -191,10 +227,11 @@ class Migrations{
         }
     }
 
-    //
+    // validate if schema has changed based on new and old
     buildUpObject(oldSchema, newSchema){
         var tableObj = {}
-        var tables = this.#buildMigrationObject(oldSchema, newSchema); 
+        var tables = this.#buildMigrationObject(oldSchema, newSchema);
+
         tables.forEach(function (item, index) {
                     // add new columns for table
                     var columnInfo = tables[index];
@@ -219,9 +256,9 @@ class Migrations{
 
                     if(item.new === null){
                         columnInfo.old.tableName = item.name;
-                        tableObj[column] = columnInfo.old;
+                        tableObj["new"] = columnInfo.old;
                     }
-
+                
                     tableObj.___table = item;
                 });
         return tableObj;
@@ -230,6 +267,7 @@ class Migrations{
     template(name, oldSchema, newSchema){
         var MT = new MigrationTemplate(name);
         var tables = this.#buildMigrationObject(oldSchema, newSchema);
+    
         tables.forEach(function (item, index) {
             if(item.old === null){
                 MT.createTable("up", column, item.name);

package/Migrations/schema.js

@@ -1,4 +1,4 @@
-// version 0.0.3
+// version 0.0.4
 class schema{
 
     constructor(context){
@@ -7,80 +7,135 @@ class schema{
 
 
     init(table){
-        this.fullTable = table.___table;
+        if(table){
+            this.fullTable = table.___table;
+        }
     }
     
     // create obj to convert into create sql
     addColumn(table){
-        if(this.context.isSQite){
-            var sqliteQuery = require("./migrationSQLiteQuery");
-            var queryBuilder = new sqliteQuery();
-            var queryObj = queryBuilder.alterColumn(this.fullTable.new, table);
-            for (var key in queryObj) {
-                var query = queryObj[key];
+        // todo need to work on add column for mysql
+        if(table){
+            if(this.context.isSQLite){
+                var sqliteQuery = require("./migrationSQLiteQuery");
+                var queryBuilder = new sqliteQuery();
+                var queryObj = queryBuilder.alterColumn(this.fullTable.new, table);
+                for (var key in queryObj) {
+                    var query = queryObj[key];
+                    this.context._execute(query);
+                }
+            }
+
+            if(this.context.isMySQL){
+                var sqlquery = require("./migrationMySQLQuery");
+                var queryBuilder = new sqlquery();
+                table.realDataType = queryBuilder.typeManager(table.type);
+                var query = queryBuilder.addColum(table);
                 this.context._execute(query);
             }
         }
+
         // add column to database
     }
 
     dropColumn(table){
-        if(this.fullTable){
-            // drop column 
-            if(this.context.isSQite){
-                var sqliteQuery = require("./migrationSQLiteQuery");
-                var queryBuilder = new sqliteQuery();
-                var query = queryBuilder.dropColumn(table);
-                this.context._execute(query);
+        if(table){
+            if(this.fullTable){
+                // drop column 
+                if(this.context.isSQLite){
+                    var sqliteQuery = require("./migrationSQLiteQuery");
+                    var queryBuilder = new sqliteQuery();
+                    var query = queryBuilder.dropColumn(table);
+                    this.context._execute(query);
+                }
+
+                if(this.context.isMySQL){
+                    var sqlquery = require("./migrationMySQLQuery");
+                    var queryBuilder = new sqlquery();
+                    var query = queryBuilder.dropColumn(table);
+                    this.context._execute(query);
+                }
+
+            }else{
+                console.log("Must call the addTable function.");
             }
-        }else{
-            console.log("Must call the addTable function.");
         }
     }
     
     createTable(table){
-        if(this.context.isSQite){
-            var sqliteQuery = require("./migrationSQLiteQuery");
-            var queryBuilder = new sqliteQuery();
-            var query = queryBuilder.createTable(table);
-            this.context._execute(query);
+
+        if(table){
+            if(this.context.isSQLite){
+                var sqliteQuery = require("./migrationSQLiteQuery");
+                var queryBuilder = new sqliteQuery();
+                var query = queryBuilder.createTable(table);
+                this.context._execute(query);
+            }
+
+            if(this.context.isMySQL){
+                var sqlquery = require("./migrationMySQLQuery");
+                var queryBuilder = new sqlquery();
+                var query = queryBuilder.createTable(table);
+                this.context._execute(query);
+            }
+        }else{
+            console.log("Table that your trying to create is undefined. PLease check if there are any changes that need to be made");
         }
     }
 
 
     dropTable(table){
-        if(this.context.isSQite){
-            var sqliteQuery = require("./migrationSQLiteQuery");
-            var queryBuilder = new sqliteQuery();
-            var query = queryBuilder.dropTable(table.__name);
-            this.context._execute(query);
+        if(table){
+            if(this.context.isSQLite){
+                var sqliteQuery = require("./migrationSQLiteQuery");
+                var queryBuilder = new sqliteQuery();
+                var query = queryBuilder.dropTable(table.__name);
+                this.context._execute(query);
+            }
+
+            if(this.context.isMySQL){
+                var sqlquery = require("./migrationMySQLQuery");
+                var queryBuilder = new sqlquery();
+                var query = queryBuilder.dropTable(table.__name);
+                this.context._execute(query);
+            }
         }
     }
 
 
    //"dbo.People", "Location"
     alterColumn(table){
-        if(this.fullTable){
-            if(this.context.isSQite){
-                var sqliteQuery = require("./migrationSQLiteQuery");
-                var queryBuilder = new sqliteQuery();
-                var queryObj = queryBuilder.alterColumn(this.fullTable.new, table);
-                for (var key in queryObj) {
-                    var query = queryObj[key];
+        if(table){
+            if(this.fullTable){
+                if(this.context.isSQLite){
+                    var sqliteQuery = require("./migrationSQLiteQuery");
+                    var queryBuilder = new sqliteQuery();
+                    var queryObj = queryBuilder.alterColumn(this.fullTable.new, table);
+                    for (var key in queryObj) {
+                        var query = queryObj[key];
+                        this.context._execute(query);
+                    }
+                }
+
+                if(this.context.isMySQL){
+                    var sqlquery = require("./migrationMySQLQuery");
+                    var queryBuilder = new sqlquery();
+                    var query = queryBuilder.alterColumn(table);
                     this.context._execute(query);
                 }
+
+            }else{
+                console.log("Must call the addTable function.");
             }
-        }else{
-            console.log("Must call the addTable function.");
         }
     }
 
     renameColumn(){
-
+        // TODO
     }
 
     seed(){
-
+        // TODO
     }
     
 }

package/QueryLanguage/queryMethods.js

@@ -198,6 +198,14 @@ class queryMethods{
             this.__reset();
             return val;
         }
+        
+        if(this.__context.isMySQL){
+            // trying to match string select and relace with select Count(*);
+            var entityValue = this.__context._SQLEngine.getCount(this.__queryObject, this.__entity, this.__context);
+            var val = entityValue[Object.keys(entityValue)[0]];
+            this.__reset();
+            return val;
+        }
     }
 
     single(){
@@ -207,6 +215,13 @@ class queryMethods{
             this.__reset();
             return sing;
         }
+        
+        if(this.__context.isMySQL){
+            var entityValue = this.__context._SQLEngine.get(this.__queryObject.script, this.__entity, this.__context);
+            var sing = this.__singleEntityBuilder(entityValue[0]);
+            this.__reset();
+            return sing;
+        }
     }
 
     toList(){
@@ -219,6 +234,16 @@ class queryMethods{
             this.__reset();
             return toLi;
         }
+
+        if(this.__context.isMySQL){
+            if(this.__queryObject.script.entityMap.length === 0){
+                this.__queryObject.skipClause( this.__entity.__name);
+            }
+            var entityValue = this.__context._SQLEngine.all(this.__queryObject.script, this.__entity, this.__context);
+            var toLi = this.__multipleEntityBuilder(entityValue);
+            this.__reset();
+            return toLi;
+        }
     }
 
       // ------------------------------- FUNCTIONS THAT UPDATE SQL START FROM HERE  -----------------------------------------------------

package/context.js

@@ -1,4 +1,4 @@
-// Version 0.0.5
+// Version 0.0.6
 
 var modelBuilder  = require('./Entity/entityModelBuilder');
 var query = require('masterrecord/QueryLanguage/queryMethods');
@@ -9,6 +9,8 @@ var insertManager = require('./insertManager');
 var deleteManager = require('./deleteManager');
 var globSearch = require("glob");
 var fs = require('fs');
+const appRoot = require('app-root-path');
+const MySQLClient = require('masterrecord/mySQLSyncConnect');
 
 class context {
     _isModelValid = {
@@ -19,14 +21,14 @@ class context {
     __builderEntities = [];
     __trackedEntities = [];
     __relationshipModels = [];
-    __enviornment = "";
+    __environment = "";
     __name = "";
     isSQLite = false;
     isMySQL = false;
     isPostgres = false;
 
     constructor(){
-        this. __enviornment = process.env.master;
+        this. __environment = process.env.master;
         this.__name = this.constructor.name;
         this._SQLEngine = "";
     }
@@ -67,12 +69,11 @@ class context {
           */
     __mysqlInit(env, sqlName){
         try{
-            
-            const mysql = require(sqlName);
-            const connection = mysql.createConnection(env);
-            connection.connect();
-            db.__name = sqlName;
-            this._MYSQLEngine = new MYSQLEngine();
+ 
+            //const mysql = require(sqlName);
+            const connection = new MySQLClient(env);
+            this._SQLEngine = new MYSQLEngine();
+            this._SQLEngine.__name = sqlName;
             return connection;
 
         }
@@ -124,7 +125,7 @@ class context {
     useSqlite(rootFolderLocation){
         this.isSQLite = true;
         var root =  process.cwd();
-        var envType = this.__enviornment;
+        var envType = this.__environment;
         var contextName = this.__name;
         var file = this.__findSettings(root, rootFolderLocation, envType);
         var settings = require(file.file);
@@ -156,16 +157,25 @@ class context {
 
     }
     
-    useMySql(options){
-        if(options !== undefined){
+    useMySql(rootFolderLocation){
+        
             this.isMySQL = true;
-            this.db = this.__mysqlInit(options, "mysql");
-            this._MYSQLEngine.setDB(this.db, "mysql");
+            var envType = this.__environment;
+            var contextName = this.__name;
+            var root = appRoot.path;
+            var file = this.__findSettings(root, rootFolderLocation, envType);
+            var settings = require(file.file);
+            var options = settings[contextName];
+            
+            if(options === undefined){
+                console.log("settings missing context name settings");
+                throw error("settings missing context name settings");
+            }
+
+            this.db = this.__mysqlInit(options, "mysql2");
+            this._SQLEngine.setDB(this.db, "mysql");
             return this;
-        }
-        else{
-            console.log("database options not defined - Master Record");
-        }
+       
     }
 
 
@@ -224,7 +234,7 @@ class context {
                     this._SQLEngine.endTransaction();
                 }
                 if(this.isMySQL){
-                    this._SQLEngine.startTransaction();
+                    //this._SQLEngine.startTransaction();
                     for (var model in tracked) {
                         var currentModel = tracked[model];
                             switch(currentModel.__state) {
@@ -256,7 +266,7 @@ class context {
                             } 
                     }
                     this.__clearErrorHandler();
-                    this._SQLEngine.endTransaction();
+                    //this._SQLEngine.endTransaction();
                 }
             }
             else{
@@ -266,7 +276,7 @@ class context {
         
         catch(error){
             this.__clearErrorHandler();
-            this._SQLEngine.errorTransaction();
+            //this._SQLEngine.errorTransaction();
             console.log("error", error);
             this.__clearTracked();
             throw error;
@@ -278,9 +288,7 @@ class context {
 
 
     _execute(query){
-        if(this.isSQLite){
-            this._SQLEngine._execute(query);
-        }
+        this._SQLEngine._execute(query);
     }
 
     // __track(model){

package/insertManager.js

@@ -1,6 +1,7 @@
 
 // version 0.0.4
 var tools =  require('./Tools');
+var queryScript = require('masterrecord/QueryLanguage/queryScript');
 
 class InsertManager {
 
@@ -8,6 +9,7 @@ class InsertManager {
         this._SQLEngine = sqlEngine;
         this._errorModel = errorModel;
         this._allEntities = allEntities;
+        this.__queryObject = new queryScript();
     }
 
     init(currentModel){
@@ -27,8 +29,10 @@ class InsertManager {
                 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];
+                    var query = `select * from ${currentModel.__entity.__name} where ${primaryKey} = ${ SQL.id }`;
+                    var jj = this.__queryObject.raw(query);
+                    var getQueryModel = this._SQLEngine.get(jj, currentModel.__entity, currentModel.__context );
+                    currentModel[primaryKey] = getQueryModel[0][primaryKey];
                 }
 
                 const modelKeys = Object.keys(currentModel);
@@ -79,7 +83,7 @@ class InsertManager {
     belongsToInsert(currentModel, modelEntity){
         var $that = this;
         for(var entity in modelEntity) {
-            if(modelEntity[entity].type === "belongsTo"){
+            if(modelEntity[entity].relationshipType === "belongsTo"){
                 var foreignKey = modelEntity[entity].foreignKey === undefined ? modelEntity[entity].name : modelEntity[entity].foreignKey;
                 var newPropertyModel = currentModel[foreignKey];
                 // check if model is a an object. If so insert the child first then the parent. 
@@ -113,21 +117,24 @@ class InsertManager {
             
                 // SKIP belongs too
                 if(currentEntity.type !== "belongsTo" && currentEntity.type !== "hasMany"){
-                    // 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.set === 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;
+                    if(currentEntity.relationshipType !== "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.set === 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.set(currentModel[entity]);
                             }
-                        }
-                        else{
-                            currentRealModel[entity] = currentEntity.set(currentModel[entity]);
                         }
                     }
+                   
                 }
             }