masterrecord 0.0.29 → 0.0.31

package/Masterrecord.js

@@ -2,252 +2,21 @@
 // https://github.com/kriasoft/node-sqlite
 // https://www.learnentityframeworkcore.com/dbset/deleting-data
 // version 1.0.19
+var context = require("./context");
+var schema = require("./Migrations/schema");
 
-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');
-var globSearch = require("glob");
-
-
-class Context {
-    _isModelValid = {
-        isValid: true,
-        errors: []
-    };
-    __entities = [];
-    __builderEntities = [];
-    __trackedEntities = [];
-    __relationshipModels = [];
-    __enviornment = "";
-    __name = "";
+class masterrecord{
 
     constructor(){
-        this. __enviornment = process.env.master;
-        this.__name = this.constructor.name;
-        this._SQLEngine = "";
-    }
-
-        /* 
-        SQLite expected model 
-        {
-            "type": "better-sqlite3",
-            "connection" : "/db/",
-            "password": "",
-            "username": ""
-        }
-    */
-    __SQLiteInit(env, sqlName){
-        try{
-            console.log("===========+++++++++++++++")
-            const sqlite3 = require(sqlName);
-            let DBAddress = env.completeConnection;
-            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: []
-        };
-    };
-
-    __findSettings(root, rootFolderLocation, envType){
-
-        var rootFolder = `${root}/${rootFolderLocation}`;
-        var search = `${rootFolder}/**/*env.${envType}.json`;
-        var files = globSearch.sync(search, rootFolder);
-        var file = files[0];
-        if(file === undefined){
-            root = tools.removeBackwardSlashSection(root, 1, "/");
-            rootFolder = `${root}/${rootFolderLocation}`;
-            var search = `${rootFolder}/**/*env.${envType}.json`;
-            var files = globSearch.sync(search,rootFolder);
-            file = files[0];
-            if(file === undefined){
-                root = tools.removeBackwardSlashSection(root, 1, "/");
-                rootFolder = `${root}/${rootFolderLocation}`;
-                var search = `${rootFolder}/**/*env.${envType}.json`;
-                var files = globSearch.sync(search,rootFolder);
-                file = files[0];
-                if(file === undefined){
-                    console.log(`could not find file - ${rootFolder}/env.${envType}.json`);
-                    throw error(`could not find file - ${rootFolder}/env.${envType}.json`);
-                }
-
-            }
-        
-        }
-        
-        return {
-            file: file,
-            rootFolder : root
-        };
-    }
-
-    useSqlite(rootFolderLocation){
-            var root =  process.cwd();
-            var envType = this.__enviornment;
-            var contextName = this.__name;
-            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.validateSQLiteOptions(options);
-            options.completeConnection = `${file.rootFolder}${options.connection}`;
-            this.db = this.__SQLiteInit(options,  "better-sqlite3");
-            this._SQLEngine.setDB(this.db, "better-sqlite3");
-            return this;
-    }
-
-    validateSQLiteOptions(options){
-        if(options.hasOwnProperty('connect') === undefined){
-            console.log("connnect string settings is missing")
-            throw error("connection string settings is missing");
-        }
-
-    }
-    
-    useMySql(options, rootFolderLocation){
-        if(options !== undefined){
-            this.db = this.__mysqlInit(options, "mysql");
-            this._SQLEngine.setDB(this.db, "mysql");
-            return this;
-        }
-        else{
-            console.log("database options not defined - 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;
+        this.context = context;
+        this.schema = schema;
     }
+}
 
-    __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 = masterrecord;
 
 
-module.exports = Context;
 
 /*
 

package/Migrations/cli.js

@@ -1,5 +1,9 @@
 #!/usr/bin/env node
-  // https://docs.microsoft.com/en-us/ef/ef6/modeling/code-first/migrations/
+
+// 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
+
 const program = require('commander');
 let fs = require('fs');
 let path = require('path');
@@ -12,7 +16,7 @@ const [,, ...args] = process.argv
 
 program
   .version('0.0.2')
-  .option('-v, --version', '0.0.2') 
+  .option('-v, --version', '0.0.31') 
   .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.
@@ -31,9 +35,7 @@ program
         var snap = {
           file : contextInstance.fileLocation,
           executedLocation : executedLocation,
-          context : new contextInstance.context({
-            root: executedLocation
-          }),
+          context : new contextInstance.context(),
           contextFileName: contextFileName.toLowerCase()
         }
 
@@ -73,14 +75,13 @@ program
   });
 
  program
-  .command('update-database <contextFileName> <environment>')
+  .command('update-database <contextFileName>')
   .alias('ud')
   .description('Apply pending migrations to database')
-  .action(function(contextFileName, environment){
-    console.log("NODE_ENV", process.NODE_ENV)
+  .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`;
@@ -88,24 +89,29 @@ program
          var file = files[0];
          var contextSnapshot = require(file);
 
-         var searchMigration = `**/*_migration.js`;
+         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
             });
-            mFiles = mFiles[0];
-            var migration = require(mFiles);
+
+            var mFile = mFiles[0];
+            console.log("ontextSnapshot -------------",mFile);
+            var migrationFile = require(mFile);
             var context = require(contextSnapshot.contextLocation);
             var contextInstance = new context();
-            var newMigrationInstance = new migration(context);
-            newMigrationInstance.up();
+
+            var newMigrationInstance = new migrationFile(context);
+    
+            var tableList = migration.callMigrationUp(contextSnapshot.schema, contextInstance.__entities);
+            //newMigrationInstance.up(tableList);
          }
         }catch (e){
           console.log("Cannot read or find file ", e);
         }
-        console.log("database updated");
+        console.log("databasedsdsd updated");
   });
 
  // we will find the migration folder inside the nearest app folder if no migration folder is location is added

package/Migrations/migrationSQLiteQuery.js

@@ -0,0 +1,92 @@
+
+
+class migrationSQLiteQuery {
+
+    addColum(table){
+        var buildDefinations = this.buildDefinations(table);
+        return `ALTER TABLE ${table.name}
+        ADD ${table.column} ${buildDefinations}`;
+
+        /*
+            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
+        */
+    }
+
+    buildDefinations(definations){
+        return "";
+    }
+
+    createTable(){
+            `CREATE TABLE devices (
+                name TEXT NOT NULL,
+                model TEXT NOT NULL,
+                Serial INTEGER NOT NULL UNIQUE
+            );`
+
+            /*
+            INTEGER PRIMARY KEY AUTOINCREMENT
+                all these are equal to interger
+            INT
+            INTEGER
+            TINYINT
+            SMALLINT
+            MEDIUMINT
+            BIGINT
+            UNSIGNED BIG INT
+            INT2
+            INT8 
+            */
+    }
+
+
+    dropTable(name){
+
+    }
+
+    dropIndex(){
+
+    }
+//"dbo.People", "Location"
+    alterColumn(){
+
+    }
+
+    renameColumn(){
+        `ALTER TABLE existing_table
+        RENAME TO new_table;`
+    }
+
+    
+}
+
+
+/*
+ ADDING NEW COLUMN SQLITE 
+     There are some restrictions on the new column:
+            The new column cannot have a UNIQUE or PRIMARY KEY constraint.
+            If the new column has a NOT NULL constraint, you must specify a default value for the column other than a NULL value.
+            The new column cannot have a default of CURRENT_TIMESTAMP, CURRENT_DATE, and CURRENT_TIME, or an expression.
+            If the new column is a foreign key and the foreign key constraint check is enabled, the new column must accept a default value NULL.
+
+*/
+
+/*
+
+DROPING A COLUMN SQLITE 
+        Possible reasons why the DROP COLUMN command can fail include:
+
+                The column is a PRIMARY KEY or part of one.
+                The column has a UNIQUE constraint.
+                The column is indexed.
+                The column is named in the WHERE clause of a partial index.
+                The column is named in a table or column CHECK constraint not associated with the column being dropped.
+                The column is used in a foreign key constraint.
+                The column is used in the expression of a generated column.
+                The column appears in a trigger or view.
+
+*/

package/Migrations/migrationTemplate.js

@@ -28,48 +28,48 @@ module.exports = ${this.name};
         `
     }
 
-    alterColumn(){
+    alterColumn(type, name){
         if(type === "up"){
-            this.up += os.EOL + `     this.alterColumn(table.name, table.column);` 
+            this.up += os.EOL + `     this.alterColumn(table.${name});` 
         }
         else{
-            this.down += os.EOL + `     this.alterColumn(table.name, table.column);` 
+            this.down += os.EOL + `     this.alterColumn(table.${name});` 
         }
     }
-    createTable(){
+    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){
+    addColumn(type, name){
         if(type === "up"){
-            this.up += os.EOL + `     this.addColumn(table.name, table.column);`
+            this.up += os.EOL + `     this.addColumn(table.${name});`
         }
         else{
-            this.down += os.EOL + `     this.addColumn(table.name, table.column);`
+            this.down += os.EOL + `     this.addColumn(table.${name});`
         }
     }
     
    
-    dropTable(type){
+    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){
+    dropColumn(type, name){
         if(type === "up"){
-            this.up += os.EOL + `     this.dropColumn(table.name, table.column);`
+            this.up += os.EOL + `     this.dropColumn(table.${name});`
         }
         else{
-            this.down += os.EOL + `     this.dropColumn(table.name, table.column);`
+            this.down += os.EOL + `     this.dropColumn(table.${name});`
         }
     }
 

package/Migrations/migrations.js

@@ -1,4 +1,4 @@
-// version 0.0.3
+// version 0.0.4
 // learn more about seeding info -  https://www.pauric.blog/Database-Updates-and-Migrations-with-Entity-Framework/
 
 var fs = require('fs');
@@ -29,9 +29,6 @@ class Migrations{
         }
     
         var content = {
-            seed : function(seed){
-                this.seed(this);
-            },
             contextLocation: snap.file,
             migrationFolder: `${snap.executedLocation}/db/migrations`,
             snapShotLocation: `${snap.executedLocation}/db/migrations/${snap.contextFileName}_contextSnapShot.json`,
@@ -129,39 +126,76 @@ class Migrations{
             return tables;
     }
 
-      
-    buildMigrationTemplate(name, oldSchema, newSchema){
-
-        var MT = new MigrationTemplate(name);
+    // 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);
+        return tables;
+    }
+
+    //
+    callMigrationUp(oldSchema, newSchema){
+        var tableArray =[];
+        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]);
+                    });
+
+                    item.deletedColumns.forEach(function (column, index) {
+                        tableArray.push(tables[column]);
+                    });
+
+                    item.updatedColumns.forEach(function (column, index) {
+                        tableArray.push(tables[column]);
+                    });
+
+                    if(item.old === null){
+                        tableArray.push(tables[column]);
+
+                    }
+                    if(item.new === null){
+                        tableArray.push(tables[column]);
+                    }
+
+                });
+
+                return tableArray;
+    }
+
+    buildMigrationTemplate(name, oldSchema, newSchema){
+
+        var MT = new MigrationTemplate(name);
+        var tables = this.buildMigrationObject(oldSchema, newSchema);
         tables.forEach(function (item, index) {
             // add new columns for table
             item.newColumns.forEach(function (column, index) {
-                MT.addColumn();
-                MT.dropColumn("down");
+                MT.addColumn("up", column);
+                MT.dropColumn("down", column);
             });
 
             item.deletedColumns.forEach(function (column, index) {
-                MT.dropColumn("up");
-                MT.addColumn("down");
+                MT.dropColumn("up", column);
+                MT.addColumn("down",column);
             });
 
             item.updatedColumns.forEach(function (column, index) {
-                MT.alterColumn();
-                MT.alterColumn("down")
+                MT.alterColumn("up", column);
+                MT.alterColumn("down", column)
             });
 
             if(item.old === null){
-                MT.createTable();
-                MT.dropTable("down");
+                MT.createTable("up", column);
+                MT.dropTable("down", column);
 
             }
             if(item.new === null){
-                MT.dropTable("up");
-                MT.createTable("down");
+                MT.dropTable("up", column);
+                MT.createTable("down", column);
             }
 
         });

package/Migrations/schema.js

@@ -1,15 +1,41 @@
 // version 1
 var fs = require('fs');
 
-class Schema{
-    
-    constructor(settings){
-        this.settings = settings;
+var table = {
+    email : {
+        name: "auth", 
+        column : "email",
+        rules: { 
+            "type": "integer",
+        "primary": true,
+        "nullable": false,
+        "unique": true,
+        "auto": true,
+        "cascadeOnDelete": true,
+        "lazyLoading": true,
+        "isNavigational": false
+
+    }
+   }
+}
+
+
+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;
     }
     
     // create obj to convert into create sql
-    addColumn(tableName, columnName, ){
-
+    addColumn(table){
+        if(this.context.isSQite){
+            var sqliteQuery = require("./migrationSQLiteQuery");
+            var query = sqliteQuery.addColumn(table);
+            this.context.db.prepare(query).all();
+        }
         // add column to database
     }
 
@@ -61,4 +87,4 @@ class Schema{
 
 */
 
-module.exports = Schema;
+module.exports = schema;

package/Migrations/test.js

@@ -0,0 +1,34 @@
+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>`
+    }
+}

package/QueryLanguage/queryMethods.js

@@ -1,7 +1,7 @@
 // ALL THIS SHOULD DO IS BUILD A SQL QUERY
 // version 1.0.222
 // TODO: change name of queryManager to select manager;
-var entityTrackerModel = require('masterrecord/Entity/EntityTrackerModel');
+var entityTrackerModel = require('masterrecord/Entity/entityTrackerModel');
 var tools = require('masterrecord/Tools');
 var queryScript = require('masterrecord/QueryLanguage/queryScript');
 

package/context.js

@@ -0,0 +1,248 @@
+
+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');
+var globSearch = require("glob");
+
+
+class Context {
+    _isModelValid = {
+        isValid: true,
+        errors: []
+    };
+    __entities = [];
+    __builderEntities = [];
+    __trackedEntities = [];
+    __relationshipModels = [];
+    __enviornment = "";
+    __name = "";
+    isSQite = false;
+    isMySQL = false;
+
+    constructor(){
+        this. __enviornment = process.env.master;
+        this.__name = this.constructor.name;
+        this._SQLEngine = "";
+    }
+
+        /* 
+        SQLite expected model 
+        {
+            "type": "better-sqlite3",
+            "connection" : "/db/",
+            "password": "",
+            "username": ""
+        }
+    */
+    __SQLiteInit(env, sqlName){
+        try{
+            const sqlite3 = require(sqlName);
+            let DBAddress = env.completeConnection;
+            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: []
+        };
+    };
+
+    __findSettings(root, rootFolderLocation, envType){
+
+        var rootFolder = `${root}/${rootFolderLocation}`;
+        var search = `${rootFolder}/**/*env.${envType}.json`;
+        var files = globSearch.sync(search, rootFolder);
+        var file = files[0];
+        if(file === undefined){
+            root = tools.removeBackwardSlashSection(root, 1, "/");
+            rootFolder = `${root}/${rootFolderLocation}`;
+            var search = `${rootFolder}/**/*env.${envType}.json`;
+            var files = globSearch.sync(search,rootFolder);
+            file = files[0];
+            if(file === undefined){
+                root = tools.removeBackwardSlashSection(root, 1, "/");
+                rootFolder = `${root}/${rootFolderLocation}`;
+                var search = `${rootFolder}/**/*env.${envType}.json`;
+                var files = globSearch.sync(search,rootFolder);
+                file = files[0];
+                if(file === undefined){
+                    console.log(`could not find file - ${rootFolder}/env.${envType}.json`);
+                    throw error(`could not find file - ${rootFolder}/env.${envType}.json`);
+                }
+
+            }
+        
+        }
+        
+        return {
+            file: file,
+            rootFolder : root
+        };
+    }
+
+    useSqlite(rootFolderLocation){
+            this.isSQite = true;
+            var root =  process.cwd();
+            var envType = this.__enviornment;
+            var contextName = this.__name;
+            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.validateSQLiteOptions(options);
+            options.completeConnection = `${file.rootFolder}${options.connection}`;
+            this.db = this.__SQLiteInit(options,  "better-sqlite3");
+            this._SQLEngine.setDB(this.db, "better-sqlite3");
+            return this;
+    }
+
+    validateSQLiteOptions(options){
+        if(options.hasOwnProperty('connect') === undefined){
+            console.log("connnect string settings is missing")
+            throw error("connection string settings is missing");
+        }
+
+    }
+    
+    useMySql(options, rootFolderLocation){
+        if(options !== undefined){
+            this.db = this.__mysqlInit(options, "mysql");
+            this._SQLEngine.setDB(this.db, "mysql");
+            return this;
+        }
+        else{
+            console.log("database options not defined - 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;

package/package.json

@@ -6,7 +6,7 @@
     "glob" : "^8.0.3",
     "deep-object-diff" : "^1.1.7"
   },
-  "version": "0.0.29",
+  "version": "0.0.31",
   "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": {