masterrecord 0.0.46 → 0.0.48

package/Entity/entityModel.js

@@ -24,11 +24,12 @@ class EntityModel {
         this.obj = {
             name: name,
             type: null,
+            relationshipType: null,
+            typeSize : null,
             primary : null,
             default : null,
             virtual : null,
             foreignKey : null,
-            maxLength : null,
             nullable : true, // no
             unique : false,
             auto : false,
@@ -41,6 +42,12 @@ class EntityModel {
         }
     }
 
+    type(type, size){
+        this.obj.type = type;
+        this.obj.typeSize = size;
+        return this;
+    }
+
     string(){
         this.obj.type = "string";
         return this;
@@ -61,10 +68,10 @@ class EntityModel {
         return this;
     }
 
-    maxLength(amount){
-        this.obj.maxLength = amount;
-        return this;
-    }
+    // maxLength(amount){
+    //     this.obj.maxLength = amount;
+    //     return this;
+    // }
 
     // will stop cascade delete which means it will stop not auto delete relationship
     stopCascadeOnDelete(){
@@ -140,6 +147,7 @@ class EntityModel {
         if(foreignKey === undefined){
             foreignKey = `${this.obj.name.toLowerCase()}_id`;
         }
+        this.obj.relationshipType = "hasMany";
         this.obj.type = "hasMany";
         this.obj.foreignTable = foreignTable;
         this.obj.foreignKey = foreignKey;
@@ -153,6 +161,7 @@ class EntityModel {
         if(foreignKey === undefined){
             foreignKey = `${this.obj.name.toLowerCase()}_id`;
         }
+        this.obj.relationshipType = "hasOne";
         this.obj.type = "hasOne";
         this.obj.foreignTable = foreignTable;
         this.obj.foreignKey = foreignKey;
@@ -166,7 +175,8 @@ class EntityModel {
     hasManyThrough(foreignTable,  foreignKey ){
         if(foreignKey === undefined){
             foreignKey = `${this.obj.name.toLowerCase()}_id`;
-        }
+        };
+        this.obj.relationshipType = "hasManyThrough";
         this.obj.type = "hasManyThrough";
         this.obj.foreignTable = foreignTable;// if joinKey is undefined then use name of object. 
         this.obj.foreignKey = foreignKey; // Foreign Key table
@@ -181,7 +191,8 @@ class EntityModel {
             foreignKey = `${foreignTable.toLowerCase()}_id`;
         }
         // will use table name to find forien key
-        this.obj.type = "belongsTo";
+        this.obj.type = "integer";
+        this.obj.relationshipType = "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

package/Entity/entityTrackerModel.js

@@ -74,7 +74,7 @@ class EntityTrackerModel {
 
     _isRelationship(entity){
         if(entity){
-            if(entity.type === "hasOne" || entity.type === "hasMany" || entity.type === "belongsTo" || entity.type === "hasManyThrough"){ 
+            if(entity.type === "hasOne" || entity.type === "hasMany" || entity.relationshipType === "belongsTo" || entity.type === "hasManyThrough"){ 
                 return true;
             }
             else{
@@ -122,7 +122,7 @@ class EntityTrackerModel {
                     }
 
                     
-                    if(currentEntity[entityField].type === "belongsTo"){
+                    if(currentEntity[entityField].relationshipType === "belongsTo"){
                         if(currentEntity[entityField].lazyLoading){
                              // TODO: UPDATE THIS CODE TO USE SOMETHING ELSE - THIS WILL NOT WORK WHEN USING DIFFERENT DATABASES BECAUSE THIS IS USING SQLITE CODE. 
                         
@@ -216,7 +216,7 @@ class EntityTrackerModel {
                 //return console.log("make db call to get value", entityField);
                 });
 
-                if(currentEntity[entityField].type === "belongsTo"){
+                if(currentEntity[entityField].relationshipType === "belongsTo"){
                     // check if entity has a value if so then return that value
                     if(currentModel[entityField]){
                         modelClass[entityField] = currentModel[entityField];

package/Migrations/cli.js

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 
-// version 0.0.7
+// version 0.0.4
 // https://docs.microsoft.com/en-us/ef/ef6/modeling/code-first/migrations/
 // how to add environment variables on cli call example - master=development masterrecord add-migration auth authContext
 
@@ -10,13 +10,13 @@ let path = require('path');
 var Migration = require('./migrations');
 var globSearch = require("glob");
 
+
 const [,, ...args] = process.argv
 
 
 
 program
-  .version('0.0.2')
-  .option('-v, --version', '0.0.34') 
+  .version('0.0.3', '-v, --version', '0.0.3')
   .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 main project folder is located and run the command using the context file name.
@@ -45,8 +45,42 @@ program
 
   });
 
+  // program
+  // .command('create-database <contextFileName> <dbName>')
+  // .alias('cd')
+  // .description('allows you to create a database')
+  // .action(function(contextFileName, dbName){
+  //     var executedLocation = process.cwd();
+  //     contextFileName = contextFileName.toLowerCase();
+          
+  //     try{
+  //        // find context file from main folder location
+  //        // find context file from main folder location
+  //        var search = `${executedLocation}/**/*${contextFileName}_contextSnapShot.json`;
+  //        var files = globSearch.sync(search, executedLocation);
+  //        var file = files[0];
+
+  //        if(file){
+  //           var contextSnapshot = require(file);
+  //           var context = require(contextSnapshot.contextLocation);
+  //           var newSchema = new schema(context);
+  //           newSchema.createDatabase(dbName);
+  //        }
+  //        else{
+  //          console.log("Error - Cannot read or find Context file");
+  //         }
+
+
+  //       }catch (e){
+  //         console.log("Error - Cannot read or find file ", e);
+  //       }
+  //       console.log("Database Created");
+
+  // });
+
+
   // Instructions : to run command you must go to folder where migration file is located.
-  program //// TODO ---- WHY MIGRATION IS CREATING ADD COLUMSN AS WELL AS NEW TABLE
+  program
   .command('add-migration <name> <contextFileName>')
   .alias('am')
   .action(function(name, contextFileName){
@@ -62,11 +96,12 @@ program
           var contextSnapshot = require(files[0]);
           var context = require(contextSnapshot.contextLocation);
           var contextInstance = new context();
-          var newEntity = migration.template(name, contextSnapshot.schema, contextInstance.__entities);
+          var cleanEntities = migration.cleanEntities(contextInstance.__entities);
+          var newEntity = migration.template(name, contextSnapshot.schema, cleanEntities);
           var migrationDate = Date.now();
           var file = `${contextSnapshot.migrationFolder}/${migrationDate}_${name}_migration.js`
           fs.writeFile(file, newEntity, 'utf8', function (err) {
-            if (err) return console.log("--- Error running cammand, rlease run command add-migration ---- ", err);
+            if (err) return console.log("--- Error running cammand, re-run command add-migration ---- ", err);
           });
           console.log(`${name} migration file created`);
         }
@@ -98,23 +133,29 @@ program
           if( migrationFiles){
             
            // find newest migration file
+           // THIS DOESNT WORK BUG - hack to fix this I just take the last file which I am asuming is the newest one
              var mFiles = migrationFiles.sort(function(x, y){
                return new Date(x.timestamp) < new Date(y.timestamp) ? 1 : -1
              });
- 
-             var mFile = mFiles[0];
+          /** ENd of BUG */
+          
+             var mFile = mFiles[mFiles.length -1];
+
              var migrationProjectFile = require(mFile);
              var context = require(contextSnapshot.contextLocation);
              var contextInstance = new context();
              var newMigrationProjectInstance = new migrationProjectFile(context);
+
              var tableObj = migration.buildUpObject(contextSnapshot.schema, contextInstance.__entities);
+             
+             var cleanEntities = migration.cleanEntities(contextInstance.__entities);
              newMigrationProjectInstance.up(tableObj);
             
              var snap = {
                file : contextSnapshot.contextLocation,
                executedLocation : executedLocation,
                context : contextInstance,
-               contextEntities : contextInstance.__entities,
+               contextEntities : cleanEntities,
                contextFileName: contextFileName
              }
  
@@ -135,6 +176,69 @@ program
   });
 
 
+  program
+  .command('update-database-restart <contextFileName>')
+  .alias('udr')
+  .description('Apply pending migrations to database - up method call')
+  .action(function(contextFileName){
+    var executedLocation = process.cwd();
+    contextFileName = contextFileName.toLowerCase();
+    var migration = new Migration();
+      try{
+         // find context file from main folder location
+         var search = `${executedLocation}/**/*${contextFileName}_contextSnapShot.json`;
+         var files = globSearch.sync(search, executedLocation);
+         var file = files[0];
+         if(file){
+          var contextSnapshot = require(file);
+          var searchMigration = `${contextSnapshot.migrationFolder}/**/*_migration.js`;
+          var migrationFiles = globSearch.sync(searchMigration, contextSnapshot.migrationFolder);
+          if( migrationFiles){
+            
+          
+            // organize by time
+            var mFiles = migrationFiles.sort(function(x, y){
+              return new Date(x.timestamp) < new Date(y.timestamp) ? 1 : -1;
+            });
+             var context = require(contextSnapshot.contextLocation);
+             
+             for (let i = 0; i < mFiles.length; i++) {
+                var file = mFiles[i];
+                var migrationProjectFile = require(file);
+
+                var contextInstance = new context();
+                var newMigrationProjectInstance = new migrationProjectFile(context);
+                var tableObj = migration.buildUpObject(contextSnapshot.schema, contextInstance.__entities);
+                var cleanEntities = migration.cleanEntities(contextInstance.__entities);
+                newMigrationProjectInstance.up(tableObj);
+            }
+        
+            
+            var snap = {
+                  file : contextSnapshot.contextLocation,
+                  executedLocation : executedLocation,
+                  context : contextInstance,
+                  contextEntities : cleanEntities,
+                  contextFileName: contextFileName
+                }
+ 
+             migration.createSnapShot(snap);
+             console.log("database updated");
+          }
+          else{
+           console.log("Error - Cannot read or find migration file");
+          }
+
+         }
+         else{
+           console.log("Error - Cannot read or find Context file");
+          }
+        }catch (e){
+          console.log("Error - Cannot read or find file ", e);
+        }
+  });
+
+
  program
  .command('get-migrations <contextFileName>')
  .alias('gm')
@@ -150,7 +254,6 @@ program
           var searchMigration = `${contextSnapshot.migrationFolder}/**/*_migration.js`;
           var migrationFiles = globSearch.sync(searchMigration, contextSnapshot.migrationFolder);
           if( migrationFiles){
-            console.log("MIgration File List", migrationFiles);
             return migrationFiles;
           }
       }
@@ -165,7 +268,9 @@ program
   .alias('udt')
   .description('Apply pending migrations to database - down method call')
   .action(function(migrationFileName){
-  // this will call all the down methods until it gets to the one your looking for. First it needs to validate that there is such a file. 
+  // this will call all the down methods until it gets to the one your looking for. First it needs to validate that there is such a file.
+  // TODO:
+  
   });
 
 

package/Migrations/migrationMySQLQuery.js

@@ -0,0 +1,299 @@
+
+// verison 0.0.1
+class migrationMySQLQuery {
+
+    #tempTableName = "_temp_alter_column_update"
+    
+    #getTableColumns(table){
+        var columnList = [];
+        for (var key in table) {
+            if(typeof table[key] === "object"){
+                columnList.push(table[key].name);
+            }
+        }
+        return columnList.join(',');;
+    }
+
+    #columnMapping(table){
+        /*
+        var mapping = {
+            "name": "id", // if this changes then call rename column
+            "type": "integer", // if this changes then call altercolumn 
+            "primary": false, // is primary key 
+            "nullable": false, // is nullable 
+            "unique": true, // vlaue has to be uniqe
+            "auto": true, // sets the value to AUTOINCREMENT
+            "cascadeOnDelete": true,
+            "lazyLoading": true,
+            "isNavigational": false
+        
+        }
+        */
+        // name TEXT NOT NULL,
+
+        var auto = table.auto ? " AUTO_INCREMENT":"";
+        var primaryKey = table.primary ? " PRIMARY KEY" : "";
+        var nullName = table.nullable ? "" : " NOT NULL";
+        var unique = table.unique ? " UNIQUE" : "";
+        var type = this.typeManager(table.type);
+        var tableName = table.name;
+        var defaultValue  = "";
+        if(table.default){
+            defaultValue = ` DEFAULT ${this.boolType(table.default)}`
+        }
+        if(table.relationshipType === 'belongsTo'){
+            tableName = table.foreignKey;
+        }
+
+        return `${tableName} ${type}${nullName}${defaultValue}${unique}${primaryKey}${auto}`;
+    }
+
+    boolType(type){
+        switch(type) {
+            case "true":
+                return "1"
+              break;
+              case "false":
+                return "0"
+              break;
+              default:
+                return type;
+        }
+    }
+
+    typeManager(type){
+        switch(type) {
+            case "string":
+                return "VARCHAR(255)"
+              break;
+            case "text":
+                return "TEXT"
+              break;
+            case "float":
+                return "fLOAT(24)"
+              break;
+            case "decimal":
+                return "DECIMAL"
+              break;
+            case "datetime":
+                return "DATETIME"
+              break;
+            case "timestamp":
+                return "TIMESTAMP"
+              break;
+            case "date":
+                return "DATE"
+              break;
+            case "time":
+                return "TIME"
+              break;
+            case "boolean":
+                return "TINYINT"
+              break;
+            case "integer":
+                return "INTEGER"
+              break;
+            case "binary":
+                return "BLOB"
+              break;
+            case "blob":
+                return "BLOB"
+              break;
+            case "json":
+                return "JSON"
+              break;
+          }
+          // :string, :text, :integer, :float, :decimal, :datetime, :timestamp, :time, :date, :binary, :boolean
+    }  
+
+    // table is the altered field
+    alterColumn( table){
+      
+        if(table){
+
+            return `ALTER TABLE ${table.tableName} MODIFY COLUMN ${this.#columnMapping(table.table)} `;
+        }
+        else{
+            console.log("table information is null");
+            return null;
+        }
+    }
+
+    alterNullable(table){
+        // check if has value
+        if(typeof table.changes.nullable !== 'undefined'){
+            // if it does we want to add that to the alter statment
+        }
+    }
+
+
+    addColum(table){
+        return `ALTER TABLE ${table.tableName}
+        ADD ${table.name} ${table.realDataType}`;
+
+        /*
+            column definations
+            NULL
+            TEXT. The value is a text string, stored using the database encoding (UTF-8, UTF-16BE or UTF-16LE).
+            BLOB. The value is a blob of data, stored exactly as it was input
+            INTEGER,
+            real
+        */
+    }
+
+    dropColumn(table){
+        /*
+        COLUMNS CANNOT BE DROPPED - RULES
+        has unique constraint
+        is indexed
+        appears in a view
+        */
+        return `ALTER TABLE ${table.tableName} DROP COLUMN ${table.name}`;
+    }
+
+    insertInto(name, table){
+        return `INSERT INTO ${name} (${this.#getTableColumns(table)})
+        SELECT ${this.#getTableColumns(table)} FROM ${this.#tempTableName}`;
+    }
+
+    createTable(table){
+
+        var queryVar = "";
+        //console.log("Dsfdsfdsf---------", table)
+        for (var key in table) {
+            if(typeof table[key] === "object"){
+
+                if(table[key].type !== "hasOne" && table[key].type  !== "hasMany" && table[key].type  !== "hasManyThrough"){
+                    queryVar += `${this.#columnMapping(table[key])}, `;
+                }
+            }
+        }
+
+        var completeQuery = `CREATE TABLE ${table.__name} (${queryVar.replace(/,\s*$/, "")});`;
+        return completeQuery;
+
+            /*
+                INTEGER PRIMARY KEY AUTOINCREMENT
+                    all these are equal to interger
+                INT
+                INTEGER
+                TINYINT
+                SMALLINT
+                MEDIUMINT
+                BIGINT
+                UNSIGNED BIG INT
+                INT2
+                INT8 
+            */
+    }
+
+
+    dropTable(name){
+        return `DROP TABLE ${name}`
+    }
+
+    renameTable(table){
+        return `ALTER TABLE ${table.tableName} RENAME TO ${table.newName}`;
+    }
+
+    renameColumn(table){
+        return `ALTER TABLE ${table.tableName} RENAME COLUMN ${table.name} TO ${table.newName}`
+    }
+
+    
+}
+
+
+module.exports = migrationMySQLQuery; 
+
+/**
+ * 
+ * 
+ * 
+ * 
+MySQL Data Types NATIVE_DATABASE_TYPES = {
+        primary_key: "bigint auto_increment PRIMARY KEY",
+        string:      { name: "varchar", limit: 255 },
+        text:        { name: "text" },
+        integer:     { name: "int", limit: 4 },
+        float:       { name: "float", limit: 24 },
+        decimal:     { name: "decimal" },
+        datetime:    { name: "datetime" },
+        timestamp:   { name: "timestamp" },
+        time:        { name: "time" },
+        date:        { name: "date" },
+        binary:      { name: "blob" },
+        blob:        { name: "blob" },
+        boolean:     { name: "tinyint", limit: 1 },
+        json:        { name: "json" },
+      }
+
+
+PostgreSQL Data Types NATIVE_DATABASE_TYPES = {
+        primary_key: "bigserial primary key",
+        string:      { name: "character varying" },
+        text:        { name: "text" },
+        integer:     { name: "integer", limit: 4 },
+        float:       { name: "float" },
+        decimal:     { name: "decimal" },
+        datetime:    {}, # set dynamically based on datetime_type
+        timestamp:   { name: "timestamp" },
+        timestamptz: { name: "timestamptz" },
+        time:        { name: "time" },
+        date:        { name: "date" },
+        daterange:   { name: "daterange" },
+        numrange:    { name: "numrange" },
+        tsrange:     { name: "tsrange" },
+        tstzrange:   { name: "tstzrange" },
+        int4range:   { name: "int4range" },
+        int8range:   { name: "int8range" },
+        binary:      { name: "bytea" },
+        boolean:     { name: "boolean" },
+        xml:         { name: "xml" },
+        tsvector:    { name: "tsvector" },
+        hstore:      { name: "hstore" },
+        inet:        { name: "inet" },
+        cidr:        { name: "cidr" },
+        macaddr:     { name: "macaddr" },
+        uuid:        { name: "uuid" },
+        json:        { name: "json" },
+        jsonb:       { name: "jsonb" },
+        ltree:       { name: "ltree" },
+        citext:      { name: "citext" },
+        point:       { name: "point" },
+        line:        { name: "line" },
+        lseg:        { name: "lseg" },
+        box:         { name: "box" },
+        path:        { name: "path" },
+        polygon:     { name: "polygon" },
+        circle:      { name: "circle" },
+        bit:         { name: "bit" },
+        bit_varying: { name: "bit varying" },
+        money:       { name: "money" },
+        interval:    { name: "interval" },
+        oid:         { name: "oid" },
+      }
+ */
+
+
+      /****
+       * 
+       * 
+       * console.log("sdfdsfdsf", this.#tempTableName);
+        return `ALTER TABLE ${table.tableName} MODIFY COLUMN NOT NULL`
+        TODO -- We need to find a way build the alter query based on the data that is changed
+        //ALTER TABLE MyTable MODIFY COLUMN comment BIGINT NOT NULL;
+        if(table){
+            table.newName = this.#tempTableName;
+            //console.log("----------------------", table)
+            return {
+                1 : this.renameTable(table),
+                2 : this.createTable(fullTable),
+                3 : this.insertInto(table.tableName, fullTable),
+                4 : this.dropTable(this.#tempTableName)
+            }
+        }
+        else{
+            console.log("table information is null")
+        }
+       */

package/Migrations/migrationTemplate.js

@@ -39,10 +39,10 @@ module.exports = ${this.name};
 
     alterColumn(type, name, parent){
         if(type === "up"){
-            this.#up += os.EOL + `     this.alterColumn(table.${parent}.${name});` 
+            this.#up += os.EOL + `     this.alterColumn(table.${name});` 
         }
         else{
-            this.#down += os.EOL + `     this.alterColumn(table.${parent}.${name});` 
+            this.#down += os.EOL + `     this.alterColumn(table.${name});` 
         }
     }
     createTable(type, name){
@@ -56,13 +56,13 @@ module.exports = ${this.name};
 
     addColumn(type, name, parent){
         if(type === "up"){
-            this.#up += os.EOL + `     this.addColumn(table.${parent}.${name});`
+            this.#up += os.EOL + `     this.addColumn(table.${name});`
         }
         else{
-            this.#down += os.EOL + `     this.addColumn(table.${parent}.${name});`
+            this.#down += os.EOL + `     this.addColumn(table.${name});`
         }
     }
-    
+    //this.addColumn(table.${parent}.${name});`
    
     dropTable(type, name){
         if(type === "up"){
@@ -75,10 +75,10 @@ module.exports = ${this.name};
 
     dropColumn(type, name, parent){
         if(type === "up"){
-            this.#up += os.EOL + `     this.dropColumn(table.${parent}.${name});`
+            this.#up += os.EOL + `     this.dropColumn(table.${name});`
         }
         else{
-            this.#down += os.EOL + `     this.dropColumn(table.${parent}.${name});`
+            this.#down += os.EOL + `     this.dropColumn(table.${name});`
         }
     }