masterrecord 0.0.31 → 0.0.33

package/Entity/entityModel.js

@@ -17,7 +17,7 @@
 
 */
 
-// version 1.0.16
+// version 0.0.2
 class EntityModel {
     
     constructor(name){

package/Entity/entityModelBuilder.js

@@ -1,4 +1,4 @@
-var modelDB  = require('./EntityModel');
+var modelDB  = require('./entityModel');
 
 // creates new instance if entity model and calls inner functions to build out a valid entity
 class EntityModelBuilder {

package/Masterrecord.js

@@ -14,7 +14,7 @@ class masterrecord{
 }
 
 
-module.exports = masterrecord;
+module.exports = new masterrecord();
 
 
 

package/Migrations/cli.js

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 
-// version 0.0.4
+// version 0.0.5
 // 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
 
@@ -16,10 +16,10 @@ const [,, ...args] = process.argv
 
 program
   .version('0.0.2')
-  .option('-v, --version', '0.0.31') 
+  .option('-v, --version', '0.0.33') 
   .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.
+  // Instructions : to run command you must go to main project folder is located and run the command using the context file name.
   program
   .command('enable-migrations <contextFileName>')
   .alias('em')
@@ -30,12 +30,13 @@ program
         // location of folder where command is being executed..
         var executedLocation = process.cwd();
         // find context file from main folder location
-        var contextInstance = migration.getContext(executedLocation, contextFileName);
-        
+        var contextInstance = migration.findContext(executedLocation, contextFileName);
+       var context =  new contextInstance.context();
         var snap = {
           file : contextInstance.fileLocation,
           executedLocation : executedLocation,
-          context : new contextInstance.context(),
+          context : context,
+          contextEntities : [],
           contextFileName: contextFileName.toLowerCase()
         }
 
@@ -54,30 +55,33 @@ program
     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 contextSnapshot = require(files[0]);
-         var context = require(contextSnapshot.contextLocation);
-         var contextInstance = new context();
-         var newEntity = migration.buildMigrationTemplate(name, contextSnapshot.schema, contextInstance .__entities);
-         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);
-
-         });
+        var search = `${executedLocation}/**/*${contextFileName}_contextSnapShot.json`;
+        var files = globSearch.sync(search, executedLocation);
+        var file = files[0];
+        if(file){
+          var contextSnapshot = require(files[0]);
+          var context = require(contextSnapshot.contextLocation);
+          var contextInstance = new context();
+          var newEntity = migration.template(name, contextSnapshot.schema, contextInstance .__entities);
+          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);
+          });
+          console.log(`${name} migration file created`);
+        }
+        else{
+          console.log("Error - Cannot read or find Context file");
+        }
        }catch (e){
-         console.log("Cannot read or find file ", e);
+         console.log("Error - Cannot read or find file ", e);
       }
-
-      console.log(`${name} migration file created`);
   });
 
  program
   .command('update-database <contextFileName>')
   .alias('ud')
-  .description('Apply pending migrations to database')
+  .description('Apply pending migrations to database - up method call')
   .action(function(contextFileName){
     var executedLocation = process.cwd();
     contextFileName = contextFileName.toLowerCase();
@@ -87,54 +91,84 @@ program
          var search = `${executedLocation}/**/*${contextFileName}_contextSnapShot.json`;
          var files = globSearch.sync(search, executedLocation);
          var file = files[0];
-         var contextSnapshot = require(file);
-
-         var searchMigration = `${contextSnapshot.migrationFolder}/**/*_migration.js`;
-         var migrationFiles = globSearch.sync(searchMigration, contextSnapshot.migrationFolder);
-         if( migrationFiles){
-          // find newest migration file
-            var mFiles = migrationFiles.sort(function(x, y){
-              return new Date(x.timestamp) < new Date(y.timestamp) ? 1 : -1
-            });
-
-            var mFile = mFiles[0];
-            console.log("ontextSnapshot -------------",mFile);
-            var migrationFile = require(mFile);
-            var context = require(contextSnapshot.contextLocation);
-            var contextInstance = new context();
-
-            var newMigrationInstance = new migrationFile(context);
-    
-            var tableList = migration.callMigrationUp(contextSnapshot.schema, contextInstance.__entities);
-            //newMigrationInstance.up(tableList);
+         if(file){
+          var contextSnapshot = require(file);
+          var searchMigration = `${contextSnapshot.migrationFolder}/**/*_migration.js`;
+          var migrationFiles = globSearch.sync(searchMigration, contextSnapshot.migrationFolder);
+          if( migrationFiles){
+            
+           // find newest migration file
+             var mFiles = migrationFiles.sort(function(x, y){
+               return new Date(x.timestamp) < new Date(y.timestamp) ? 1 : -1
+             });
+ 
+             var mFile = mFiles[0];
+             var migrationFile = require(mFile);
+             var context = require(contextSnapshot.contextLocation);
+             var contextInstance = new context();
+             var newMigrationInstance = new migrationFile(context);
+        
+             var tableObj = migration.up(contextSnapshot.schema, contextInstance.__entities);
+             newMigrationInstance.up(tableObj);
+            
+             var snap = {
+               file : contextSnapshot.contextLocation,
+               executedLocation : executedLocation,
+               context : contextInstance,
+               contextEntities : contextInstance.__entities,
+               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("Cannot read or find file ", e);
+          console.log("Error - Cannot read or find file ", e);
         }
-        console.log("databasedsdsd updated");
   });
 
- // 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){
-    // remove migrations call the down method of a migration             newMigrationInstance.down();
-    // find migration file using name and delete it.
-  });
 
+ program
+ .command('get-migrations <contextFileName>')
+ .alias('gm')
+ .description('Get a list of migration file names using the context')
+ .action(function(contextFileName){
+      var executedLocation = process.cwd();
+      contextFileName = contextFileName.toLowerCase();
+      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){
+            console.log("MIgration File List", migrationFiles);
+            return migrationFiles;
+          }
+      }
+      else{
+        console.log("Error - Cannot read or find Context file");
+      }
+ });
 
- // we will find the migration folder inside the nearest app folder if no migration folder is location is added
+  // 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"
+  .command('update-database-target <migrationFileName>')
+  .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. 
   });
 
+
+
 program.parse(process.argv);

package/Migrations/migrationSQLiteQuery.js

@@ -1,11 +1,82 @@
 
-
+// verison 0.0.3
 class migrationSQLiteQuery {
 
+    #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 chnages 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 ? " AUTOINCREMENT":"";
+        var primaryKey = table.primary ? " PRIMARY KEY" : "";
+        var nullName = table.nullable ? "" : " NOT NULL";
+        var unique = table.unique ? " UNIQUE" : "";
+        var type = this.#typeManager(table.type);
+
+        return `${table.name} ${type}${nullName}${unique}${primaryKey}${auto}`;
+    }
+
+    #typeManager(type){
+        switch(type) {
+            case "string":
+                return "TEXT"
+              break;
+            case "time":
+                return "TEXT"
+              break;
+              case "boolean":
+                return "INTEGER"
+              break;
+              case "integer":
+                return "INTEGER"
+              break;
+          }
+          
+    }  
+
+    alterColumn(fullTable, table){
+        if(table){
+            table.newName = this.tempTableName;
+            return {
+                1 : this.renameTable(table),
+                2 : this.createTable(table.tableName, fullTable),
+                3 : this.insertInto(table.tableName, fullTable),
+                4 : this.dropTable(this.tempTableName)
+            }
+        }
+        else{
+            console.log("table information is null")
+        }
+    }
+
+
     addColum(table){
-        var buildDefinations = this.buildDefinations(table);
-        return `ALTER TABLE ${table.name}
-        ADD ${table.column} ${buildDefinations}`;
+        return `ALTER TABLE ${table.tableName}
+        ADD COLUMN ${table.name}`;
 
         /*
             column definations
@@ -17,16 +88,30 @@ class migrationSQLiteQuery {
         */
     }
 
-    buildDefinations(definations){
-        return "";
+    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(){
-            `CREATE TABLE devices (
-                name TEXT NOT NULL,
-                model TEXT NOT NULL,
-                Serial INTEGER NOT NULL UNIQUE
-            );`
+    createTable(table){
+        var queryVar = "";
+        for (var key in table) {
+            if(typeof table[key] === "object"){
+                queryVar += `${this.#columnMapping(table[key])}, `;
+            }
+        }
+     
+        return `CREATE TABLE ${table.__name} (${queryVar.replace(/,\s*$/, "")});`;
 
             /*
             INTEGER PRIMARY KEY AUTOINCREMENT
@@ -45,26 +130,24 @@ class migrationSQLiteQuery {
 
 
     dropTable(name){
-
+        return `DROP TABLE ${name}`
     }
 
-    dropIndex(){
-
-    }
-//"dbo.People", "Location"
-    alterColumn(){
-
+    renameTable(table){
+        return `ALTER TABLE ${table.tableName} RENAME TO ${table.newName}`;
     }
 
-    renameColumn(){
-        `ALTER TABLE existing_table
-        RENAME TO new_table;`
+    renameColumn(table){
+        return `ALTER TABLE ${table.tableName} RENAME COLUMN ${table.name} TO ${table.newName}`
     }
 
     
 }
 
 
+module.exports = migrationSQLiteQuery; 
+
+
 /*
  ADDING NEW COLUMN SQLITE 
      There are some restrictions on the new column:

package/Migrations/migrationTemplate.js

@@ -1,75 +1,84 @@
-const os = require('os');
+
 
 // https://channel9.msdn.com/Blogs/EF/Migrations-Under-the-Hood
+// version 0.0.3
 
+const os = require('os');
 class MigrationTemplate {
-    up = ''
-    down = ''
+
     constructor(name) {
-      this.name = name;
+        this.name = name;
     }
 
+    #up = ''
+    #down = ''
+
     get(){
         return ` 
-class ${this.name} extends Schema { 
+         
+var masterrecord = require('masterrecord');
+
+class ${this.name} extends masterrecord.schema { 
     constructor(context){
         super(context);
     }
 
     up(table){
-        ${this.up}
+        this.init(table);
+        ${this.#up}
     }
 
     down(table){
-        ${this.down}
+        this.init(table);
+        ${this.#down}
     }
 }
 module.exports = ${this.name};
         `
     }
 
-    alterColumn(type, name){
+    alterColumn(type, name, parent){
         if(type === "up"){
-            this.up += os.EOL + `     this.alterColumn(table.${name});` 
+            this.#up += os.EOL + `     this.alterColumn(table.${parent}.${name});` 
         }
         else{
-            this.down += os.EOL + `     this.alterColumn(table.${name});` 
+            this.#down += os.EOL + `     this.alterColumn(table.${parent}.${name});` 
         }
     }
     createTable(type, name){
         if(type === "up"){
-            this.up += os.EOL + `     this.createTable(table.${name});` 
+            this.#up += os.EOL + `     this.createTable(table.${name});` 
         }
         else{
-            this.down += os.EOL + `     this.createTable(table.${name});` 
+            this.#down += os.EOL + `     this.createTable(table.${name});` 
         }
     }
 
-    addColumn(type, name){
+    addColumn(type, name, parent){
         if(type === "up"){
-            this.up += os.EOL + `     this.addColumn(table.${name});`
+            this.#up += os.EOL + `     this.addColumn(table.${parent}.${name});`
         }
         else{
-            this.down += os.EOL + `     this.addColumn(table.${name});`
+            this.#down += os.EOL + `     this.addColumn(table.${parent}.${name});`
         }
     }
     
    
     dropTable(type, name){
         if(type === "up"){
-            this.down += os.EOL + `    this.droptable(table.${name});`
+            this.#down += os.EOL + `    this.droptable(table.${name});`
         }
         else{
-            this.down += os.EOL + `    this.droptable(table.${name});`
+            this.#down += os.EOL + `    this.droptable(table.${name});`
         }
     }
 
-    dropColumn(type, name){
+    dropColumn(type, name, parent){
         if(type === "up"){
-            this.up += os.EOL + `     this.dropColumn(table.${name});`
+            this.#up += os.EOL + `     this.dropColumn(table.${parent}.${name});`
         }
         else{
-            this.down += os.EOL + `     this.dropColumn(table.${name});`
+            this.#down += os.EOL + `     this.dropColumn(table.${parent}.${name});`
         }
     }
 

package/Migrations/migrations.js

@@ -1,4 +1,4 @@
-// version 0.0.4
+// version 0.0.5
 // learn more about seeding info -  https://www.pauric.blog/Database-Updates-and-Migrations-with-Entity-Framework/
 
 var fs = require('fs');
@@ -11,66 +11,49 @@ var globSearch = require("glob");
 // node masterrecord add-migration josh C:\Users\rbatista\Downloads\kollege\freshmen\app\models\context
 class Migrations{
 
-    getContext(executedLocation, contextFileName){
-        var search = `${executedLocation}/**/*${contextFileName}.js`
-        var files = globSearch.sync(search, executedLocation);
-        var file = files[0];
-        var context = require(file);
-        return {
-            context : context,
-            fileLocation : file
-            }
-    }
-
-    createSnapShot(snap){
-        var migrationsDirectory = `${snap.executedLocation}/db/migrations`;
-        if (!fs.existsSync(migrationsDirectory)){
-            fs.mkdirSync(migrationsDirectory);
-        }
-    
-        var content = {
-            contextLocation: snap.file,
-            migrationFolder: `${snap.executedLocation}/db/migrations`,
-            snapShotLocation: `${snap.executedLocation}/db/migrations/${snap.contextFileName}_contextSnapShot.json`,
-            schema : snap.context.__entities
-        };
-    
-        const jsonContent = JSON.stringify(content, null, 2);
-        try{
-          // will replace the whole file if it exist
-            fs.writeFileSync(`${migrationsDirectory}/${snap.contextFileName}_contextSnapShot.json`, jsonContent);
-        }catch (e){
-            console.log("Cannot write file ", e);
-        }
-    }
-
-    organizeSchemaByTables(oldSchema, newSchema){
+    #organizeSchemaByTables(oldSchema, newSchema){
             var tables = []
-
-            newSchema.forEach(function (item, index) {
-
-                var table = {
-                    name: item["__name"],
-                    old: null,
-                    new :item,
-                    newColumns : [],
-                    deletedColumns : [],
-                    updatedColumns : []
-                }
-                
-                oldSchema.forEach(function (oldItem, index) {
-                    var oldItemName = oldItem["__name"];
-                    if(table.name === oldItemName){
-                        table.old = oldItem;
-                        tables.push(table);
+            if(oldSchema.length === 0){
+                newSchema.forEach(function (item, index) {
+                    var table = {
+                        name: item["__name"],
+                        new :item,
+                        old : {},
+                        newColumns : [],
+                        newTables : [],
+                        deletedColumns : [],
+                        updatedColumns : []
                     }
+                    tables.push(table);
                 });
-            });
+            }
+            else{
+                newSchema.forEach(function (item, index) {
+                    var table = {
+                        name: item["__name"],
+                        old: null,
+                        new :item,
+                        newColumns : [],
+                        newTables : [],
+                        deletedColumns : [],
+                        updatedColumns : []
+                    }
+                    
+                    oldSchema.forEach(function (oldItem, index) {
+                        var oldItemName = oldItem["__name"];
+                        if(table.name === oldItemName){
+                            table.old = oldItem;
+                            tables.push(table);
+                        }
+                    });
+    
+                });
+            }
 
             return tables;
     }
 
-    findDeletedColumnsInTables(tables){
+    #findDeletedColumns(tables){
             tables.forEach(function (item, index) {
                 var deletedColumn = null;
                 if(item.new && item.old){
@@ -92,123 +75,193 @@ class Migrations{
             return tables;
     }
 
-    findUpdatedColumns(tables){
+    #findUpdatedColumns(tables){
         tables.forEach(function (item, index) {
             var UD = diff.updatedDiff(item.old, item.new);
             const isEmpty = Object.keys(UD).length === 0;
             if(!isEmpty){
-                item.updatedColumns.push(diff.updatedDiff(item.old, item.new));
+                for (var key in UD) {
+                    var tableChanges = {
+                        changes : UD[key],
+                        table : item.new[key],
+                        tableName : item.name
+                    };
+                    item.updatedColumns.push(tableChanges);
+                }
             }
            
         });
         return tables;
     }
 
-    findNewColumnsInTables(tables){
+    #findNewColumns(tables){
             tables.forEach(function (item, index) {
-                var newColumn = null;
                 if(item.new && item.old){
                     Object.keys(item.new).forEach(function (key) {
-                        var value = item.new[key].name;
-                        newColumn = null;
-                        Object.keys(item.old).forEach(function (oldKey) {
-                            var oldValue = item.old[oldKey].name;
-                            if(value === oldValue){
-                                newColumn = value;
+                        if(typeof item.new[key] === "object"){
+                            var value = item.new[key].name;
+                            var columnNotFound = false;
+                            Object.keys(item.old).forEach(function (oldKey) {
+                                if(typeof item.old[oldKey] === "object"){
+                                    var oldValue = item.old[oldKey].name;
+                                    if(value === oldValue){
+                                        columnNotFound = true;
+                                    }
+                                }
+                            });
+
+                            if(columnNotFound === false){
+                                // this means it did not find the column 
+                                item.newColumns.push(value);
                             }
-                        });
-                        if(newColumn === null){
-                            item.newColumns.push(value);
                         }
+                        
                     });
                 }
+                else{
+                    console.log("Table object has no old or new values");
+                }
             });
             return tables;
     }
 
+    #findNewTables(tables){
+        // find new tables 
+        tables.forEach(function (item, index) {
+            if(item.new && item.old){
+                    if(Object.keys(item.old).length === 0){
+                        item.newTables.push(item);
+                    }
+            }else{
+                console.log("Cannot find NEW or and Old Objects");
+            }
+
+        });
+        return tables;
+    }
+
     // build table to build new migration snapshot
-    buildMigrationObject(oldSchema, newSchema){
-        var tables = this.organizeSchemaByTables(oldSchema, newSchema);
-        tables = this.findNewColumnsInTables(tables);
-        tables = this.findDeletedColumnsInTables(tables);
-        tables = this.findUpdatedColumns(tables);
+    #buildMigrationObject(oldSchema, newSchema){
+        var tables = this.#organizeSchemaByTables(oldSchema, newSchema);
+        tables = this.#findNewTables(tables);
+        tables = this.#findNewColumns(tables);
+        tables = this.#findDeletedColumns(tables);
+        tables = this.#findUpdatedColumns(tables);
         return tables;
     }
 
+
+
+    findContext(executedLocation, contextFileName){
+        var search = `${executedLocation}/**/*${contextFileName}.js`
+        var files = globSearch.sync(search, executedLocation);
+        var file = files[0];
+        var context = require(file);
+        return {
+            context : context,
+            fileLocation : file
+            }
+    }
+
+    createSnapShot(snap){
+        var migrationsDirectory = `${snap.executedLocation}/db/migrations`;
+        if (!fs.existsSync(migrationsDirectory)){
+            fs.mkdirSync(migrationsDirectory);
+        }
+    
+        var content = {
+            contextLocation: snap.file,
+            migrationFolder: `${snap.executedLocation}/db/migrations`,
+            snapShotLocation: `${snap.executedLocation}/db/migrations/${snap.contextFileName}_contextSnapShot.json`,
+            schema : snap.contextEntities
+        };
+    
+        const jsonContent = JSON.stringify(content, null, 2);
+        try{
+          // will replace the whole file if it exist
+            fs.writeFileSync(`${migrationsDirectory}/${snap.contextFileName}_contextSnapShot.json`, jsonContent);
+        }catch (e){
+            console.log("Cannot write file ", e);
+        }
+    }
+
     //
-    callMigrationUp(oldSchema, newSchema){
-        var tableArray =[];
-        var tables = this.buildMigrationObject(oldSchema, newSchema);
+    up(oldSchema, newSchema){
+        var tableObj = {}
+        var tables = this.#buildMigrationObject(oldSchema, newSchema); 
         tables.forEach(function (item, index) {
-
                     // add new columns for table
-                    item.newColumns.forEach(function (column, index) {
-                        tableArray.push(tables[column]);
+                    var columnInfo = tables[index];
+                    
+                    item.newColumns.forEach(function (column, ind) {
+                        columnInfo.new[column].tableName = item.name;
+                        tableObj[column] = columnInfo.new[column];
                     });
 
-                    item.deletedColumns.forEach(function (column, index) {
-                        tableArray.push(tables[column]);
+                    item.newTables.forEach(function (column, ind) {
+                        tableObj[item.name] = columnInfo.new;
                     });
 
-                    item.updatedColumns.forEach(function (column, index) {
-                        tableArray.push(tables[column]);
+                    item.deletedColumns.forEach(function (column, ind) {
+                        columnInfo.old[column].tableName = item.name;
+                        tableObj[column] = columnInfo.old[column];
                     });
 
-                    if(item.old === null){
-                        tableArray.push(tables[column]);
+                    item.updatedColumns.forEach(function (column, ind) {
+                        tableObj[column.table.name] = column;
+                    });
 
-                    }
                     if(item.new === null){
-                        tableArray.push(tables[column]);
+                        columnInfo.old.tableName = item.name;
+                        tableObj[column] = columnInfo.old;
                     }
 
+                    tableObj.___table = item;
                 });
-
-                return tableArray;
+                return tableObj;
     }
 
-    buildMigrationTemplate(name, oldSchema, newSchema){
-
+    template(name, oldSchema, newSchema){
         var MT = new MigrationTemplate(name);
-        var tables = this.buildMigrationObject(oldSchema, newSchema);
+        var tables = this.#buildMigrationObject(oldSchema, newSchema);
         tables.forEach(function (item, index) {
             // add new columns for table
             item.newColumns.forEach(function (column, index) {
-                MT.addColumn("up", column);
-                MT.dropColumn("down", column);
+                MT.addColumn("up", column, item.name);
+                MT.dropColumn("down", column, item.name);
+            });
+
+            item.newTables.forEach(function (column, ind) {
+                MT.createTable("up", item.name);
+                MT.dropTable("down", item.name);
             });
 
             item.deletedColumns.forEach(function (column, index) {
-                MT.dropColumn("up", column);
-                MT.addColumn("down",column);
+                MT.dropColumn("up", column, item.name);
+                MT.addColumn("down",column, item.name);
             });
 
             item.updatedColumns.forEach(function (column, index) {
-                MT.alterColumn("up", column);
-                MT.alterColumn("down", column)
+                const isEmpty = Object.keys(column).length === 0;
+                if(!isEmpty){
+                    MT.alterColumn("up", column.table.name, item.name);
+                    MT.alterColumn("down", column.table.name, item.name);
+                }
             });
 
             if(item.old === null){
-                MT.createTable("up", column);
-                MT.dropTable("down", column);
+                MT.createTable("up", column, item.name);
+                MT.dropTable("down", column, item.name);
 
             }
             if(item.new === null){
-                MT.dropTable("up", column);
-                MT.createTable("down", column);
+                MT.dropTable("up", column, item.name);
+                MT.createTable("down", column, item.name);
             }
 
         });
 
        return MT.get();
-    
-
-    }
-
-    migrationCodeGenerator(name, column, migrationDate){
-        // will create migration file with data needed
-        // using the migration template
-
     }
 
 

package/Migrations/schema.js

@@ -1,63 +1,78 @@
-// version 1
-var fs = require('fs');
-
-var table = {
-    email : {
-        name: "auth", 
-        column : "email",
-        rules: { 
-            "type": "integer",
-        "primary": true,
-        "nullable": false,
-        "unique": true,
-        "auto": true,
-        "cascadeOnDelete": true,
-        "lazyLoading": true,
-        "isNavigational": false
+// version 0.0.3
+class schema{
 
+    constructor(context){
+        this.context = new context();
     }
-   }
-}
 
 
-class schema{
-    // TODO : check what database we are using
-    // based on the database you can make the call to update the database.
-
-
-    constructor(context){
-        this.context = context;
+    init(table){
+        this.fullTable = table.___table;
     }
     
     // create obj to convert into create sql
     addColumn(table){
         if(this.context.isSQite){
             var sqliteQuery = require("./migrationSQLiteQuery");
-            var query = sqliteQuery.addColumn(table);
-            this.context.db.prepare(query).all();
+            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);
+            }
         }
         // add column to database
     }
 
-    createTable(name, columns){
-
+    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);
+            }
+        }else{
+            console.log("Must call the addTable function.");
+        }
     }
-
-    dropColumn(tableName, columnName){
-        // drop column 
-
+    
+    createTable(table){
+        if(this.context.isSQite){
+            var sqliteQuery = require("./migrationSQLiteQuery");
+            var queryBuilder = new sqliteQuery();
+            var query = queryBuilder.createTable(table);
+            this.context._execute(query);
+        }
     }
 
-    dropTable(name){
 
+    dropTable(table){
+        if(this.context.isSQite){
+            var sqliteQuery = require("./migrationSQLiteQuery");
+            var queryBuilder = new sqliteQuery();
+            var query = queryBuilder.dropTable(table.__name);
+            this.context._execute(query);
+        }
     }
 
-    dropIndex(){
-
-    }
-//"dbo.People", "Location"
-    alterColumn(){
 
+   //"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];
+                    this.context._execute(query);
+                }
+            }
+        }else{
+            console.log("Must call the addTable function.");
+        }
     }
 
     renameColumn(){
@@ -67,24 +82,8 @@ class schema{
     seed(){
 
     }
-
-    // will get the data and create the file
-    done(){
-
-
-    }
     
 }
 
 
-/*
-    up and down function..
-    on commmand line call of run migrations with folder location of context. it will
-    load context and all the objects.
-    it will then match objects with migration data. 
-    if it's a new item it will generate a new migration dependent on what comes from migration. 
-    
-
-*/
-
 module.exports = schema;

package/SQLLiteEngine.js

@@ -1,3 +1,4 @@
+// Version 0.0.1
 var tools =  require('masterrecord/Tools');
 
 class SQLLiteEngine {

package/context.js

@@ -1,3 +1,4 @@
+// Version 0.0.1
 
 var modelBuilder  = require('./Entity/EntityModelBuilder');
 var query = require('masterrecord/QueryLanguage/queryMethods');
@@ -9,7 +10,7 @@ var deleteManager = require('./DeleteManager');
 var globSearch = require("glob");
 
 
-class Context {
+class context {
     _isModelValid = {
         isValid: true,
         errors: []
@@ -68,7 +69,7 @@ class Context {
             const connection = mysql.createConnection(env);
             connection.connect();
             db.__name = sqlName;
-            this._SQLEngine = new MYSQLEngine();
+            this._MYSQLEngine = new MYSQLEngine();
             return connection;
 
         }
@@ -149,7 +150,7 @@ class Context {
     useMySql(options, rootFolderLocation){
         if(options !== undefined){
             this.db = this.__mysqlInit(options, "mysql");
-            this._SQLEngine.setDB(this.db, "mysql");
+            this._MYSQLEngine.setDB(this.db, "mysql");
             return this;
         }
         else{
@@ -175,39 +176,41 @@ class Context {
         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;
-                    } 
+            if(this.isSQite){
+                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();
             }
-            this.__clearErrorHandler();
-            this._SQLEngine.endTransaction();
         }
         
         catch(error){
@@ -222,6 +225,13 @@ class Context {
         return true;
     }
 
+
+    _execute(query){
+        if(this.isSQite){
+            this._SQLEngine._execute(query);
+        }
+    }
+
     // TODO: WHY WE HAVE DOUBLE TRACKED OBJECTS - LOOP THROUGH ALL TRACKED OBJECTS
     __track(model){
         this.__trackedEntities.push(model);
@@ -245,4 +255,4 @@ class Context {
 }
 
 
-module.exports = Context;
+module.exports = context;

package/package.json

@@ -6,7 +6,7 @@
     "glob" : "^8.0.3",
     "deep-object-diff" : "^1.1.7"
   },
-  "version": "0.0.31",
+  "version": "0.0.33",
   "description": "An Object-relational mapping for the Master framework. Master Record connects classes to relational database tables to establish a database with almost zero-configuration ",
   "homepage": "https://github.com/Tailor/MasterRecord#readme",
   "repository": {

package/Migrations/schemaTemplate.js

@@ -1 +0,0 @@
-// will be the template used to create the scheme section 

package/Migrations/test.js

@@ -1,34 +0,0 @@
-class temp {
-
-
-    hatml = 
-    buildMOdal(className, header, body){
-
-        `
-        Copy
-        <div class="modal" tabindex="-1" role="dialog" ${className}>
-          <div class="modal-dialog" role="document">
-            <div class="modal-content">
-              <div class="modal-header">
-                ${ buildheader(header)}
-                <button type="button" class="close" data-dismiss="modal" aria-label="Close">
-                  <span aria-hidden="true">&times;</span>
-                </button>
-              </div>
-              <div class="modal-body">
-               ${body}
-              </div>
-              <div class="modal-footer">
-                <button type="button" class="btn btn-primary">Save changes</button>
-                <button type="button" class="btn btn-secondary" data-dismiss="modal">Close</button>
-              </div>
-            </div>
-          </div>
-        </div>`
-
-    }
-
-    buildheader(title){
-        return ` <h5 class="modal-title">${title}</h5>`
-    }
-}