masterrecord 0.0.26 → 0.0.28

package/Masterrecord.js

@@ -1,7 +1,7 @@
 
 // https://github.com/kriasoft/node-sqlite
 // https://www.learnentityframeworkcore.com/dbset/deleting-data
-// version 1.0.14
+// version 1.0.16
 
 var modelBuilder  = require('./Entity/EntityModelBuilder');
 var query = require('masterrecord/QueryLanguage/queryMethods');
@@ -10,6 +10,8 @@ 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 = {
@@ -20,12 +22,13 @@ class Context {
     __builderEntities = [];
     __trackedEntities = [];
     __relationshipModels = [];
+    __enviornment = "";
+    __name = "";
 
     constructor(){
-        // TODO when we build the sql engine it depends on the which type.
-
-        this._SQLEngine = "";
+        this. __enviornment = process.env.master;
         this.__name = this.constructor.name;
+        this._SQLEngine = "";
     }
 
         /* 
@@ -40,7 +43,8 @@ class Context {
     __SQLiteInit(env, sqlName){
         try{
             const sqlite3 = require(sqlName);
-            let DBAddress = `${env.completeConnection}${env.env}.sqlite3`;
+            console.log("sdsdsds", env)
+            let DBAddress = env.completeConnection;
             var db = new sqlite3(DBAddress, env);
             db.__name = sqlName;
             this._SQLEngine = new SQLLiteEngine();
@@ -84,35 +88,78 @@ class Context {
             errors: []
         };
     };
-    
-    setup(options, rootFolderLocation){
-        
-        if(options !== undefined){
-            if(options.type !== undefined){
-                switch(options.type) {
-                    case "better-sqlite3":
-                        options.completeConnection = rootFolderLocation + options.connection;
-                        this.db = this.__SQLiteInit(options, options.type);
-                        this._SQLEngine.setDB(this.db, "better-sqlite3");
-                        return this;
-                    break;
-                    case "mysql":
-                        this.db = this.__mysqlInit(options, options.type);
-                        this._SQLEngine.setDB(this.db, "mysql");
-                        return this;
-                    break;
+
+    __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`);
                 }
+
             }
-            else{
-                console.log("database type not defined - Master Record");
+        
+        }
+        
+        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 information not added - Master Record");
+            console.log("database options not defined - Master Record");
         }
-        
     }
 
+
     dbset(model, name){
         var validModel = modelBuilder.create(model);
         validModel.__name = name === undefined ? model.name : name;

package/Migrations/cli.js

@@ -4,82 +4,108 @@ const program = require('commander');
 let fs = require('fs');
 let path = require('path');
 var Migration = require('./migrations');
+var globSearch = require("glob");
 
 const [,, ...args] = process.argv
 
+
+
 program
-  .version('0.0.1')
-  .option('-v, --version', '0.0.1') 
+  .version('0.0.2')
+  .option('-v, --version', '0.0.2') 
   .description('A ORM framework that facilitates the creation and use of business objects whose data requires persistent storage to a database');
 
-  // Instructions : to run command you must go to folder where context file is located and run command with context file name.
+  // 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('am')
-  .description('Enables the migration in your project by creating a Configuration class called ContextModelSnapShot.json')
+  .alias('em')
+  .description('Enables the migration in your project by creating a configuration class called ContextSnapShot.json')
   .action(function(contextFileName){
+
+        var migration = new Migration();
         // location of folder where command is being executed..
         var executedLocation = process.cwd();
-        // go back 1 folder level
-        let previousFolder = path.join(executedLocation, '../');
-        var migrationsDirectory = `${previousFolder}/Migrations`;
-        if (!fs.existsSync(migrationsDirectory)){
-            fs.mkdirSync(migrationsDirectory);
+        // find context file from main folder location
+        var contextInstance = migration.getContext(executedLocation, contextFileName);
+        
+        var snap = {
+          file : contextInstance.fileLocation,
+          executedLocation : executedLocation,
+          context : new contextInstance.context({
+            root: executedLocation
+          }),
+          contextFileName: contextFileName.toLowerCase()
         }
 
-        var content = {
-            contextLocation: `${executedLocation}/${contextFileName}.js`,
-            migrationLocation: `${executedLocation}/Migrations`,
-            schema : {}
-        };
-        const jsonContent = JSON.stringify(content, null, 2);
-        try{
-          // will replace the whole file if it exist
-            fs.writeFileSync(`${migrationsDirectory}/ContextSnapShot.json`, jsonContent);
-        }catch (e){
-            console.log("Cannot write file ", e);
-        }
+        migration.createSnapShot(snap);
+        console.log("Migration enabled")
+
   });
 
   // Instructions : to run command you must go to folder where migration file is located.
   program
-  .command('add-migration <name>')
+  .command('add-migration <name> <contextFileName>')
   .alias('am')
-  .description('Creates a new migration class')
-  .action(function(name){
-
+  .action(function(name, contextFileName){
+    var executedLocation = process.cwd();
+    contextFileName = contextFileName.toLowerCase();
+    var migration = new Migration();
       try{
-        var contextSnapshot = fs.readFileSync(`./ContextSnapShot.json`, 'utf8');
-        var migration = new Migration();
-        var context = require(contextSnapshot.contextLocation);
-        var newEntity = migration.EDMModelDiffer(contextSnapshot.schema, context);
-        if(newEntity.length > 0){
-            var migrationDate = Date.now();
-            migration.migrationCodeGenerator(name, newEntity, migrationDate);
-            console.log(`migration ${name}_${migrationDate} created`);
-        }
-      }catch (e){
-          console.log("Cannot read or find file ", e);
+          // 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);
+
+         });
+       }catch (e){
+         console.log("Cannot read or find file ", e);
       }
 
+      console.log(`${name} migration file created`);
   });
 
- // will use the database settings to call and get the schema_migration table
- // we will get the list of all migrations that have been ran
- // we will compare that list with the folder of migrations to see if we ran everything 
- // the migrations we missed we will call the up method
- // the up method will run the create database functions
-// then update the database.js schema
-
  program
-  .command('update-database <databaseSettingLocation> <migrationFolderLocation> ')
+  .command('update-database <contextFileName> <environment>')
   .alias('ud')
   .description('Apply pending migrations to database')
-  .action(function(cmd){
-      var dir = process.cwd();
-      console.log("starting server");
-      require(dir + '/server.js');
-    //return "node c:\node\server.js"
+  .action(function(contextFileName, environment){
+    console.log("NODE_ENV", process.NODE_ENV)
+    var executedLocation = process.cwd();
+    contextFileName = contextFileName.toLowerCase();
+
+      try{
+         // find context file from main folder location
+         var search = `${executedLocation}/**/*${contextFileName}_contextSnapShot.json`;
+         var files = globSearch.sync(search, executedLocation);
+         var file = files[0];
+         var contextSnapshot = require(file);
+
+         var searchMigration = `**/*_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 context = require(contextSnapshot.contextLocation);
+            var contextInstance = new context();
+            var newMigrationInstance = new migration(context);
+            newMigrationInstance.up();
+         }
+        }catch (e){
+          console.log("Cannot read or find file ", e);
+        }
+        console.log("database updated");
   });
 
  // we will find the migration folder inside the nearest app folder if no migration folder is location is added
@@ -88,6 +114,7 @@ program
   .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.
   });
 

package/Migrations/migrationTemplate.js

@@ -1,64 +1,79 @@
-var Schema = require('./schema');
-
+const os = require('os');
 
 // https://channel9.msdn.com/Blogs/EF/Migrations-Under-the-Hood
 
-
-// migration Logic
-// using the command line run the command - "add migration 'name' 'context file location' ";
-// this will call the context which will return on object of entities
-// then call the previous migration and pass that model object and the context object to the EDMModelDiffer
-// the EDMModelDiffer function to calculate database changes
-// EDMModelDiffer will return only database changes model that have not been implemented already
-// we then create the miration using function 'migrationCodeGenerator' based on the model that was provided by EDMModelDiffer
-// js date stamp Date.now()
-
-class Migration extends Schema {
-
-    constructor() {
-        super();
+class MigrationTemplate {
+    up = ''
+    down = ''
+    constructor(name) {
+      this.name = name;
     }
 
-    static up(){
-
-        this.createTable("user", {
-            id : {
-                type : "integer",
-                primary : true,
-                unique : true,
-                nullable : false
-            },
-            user_id : {
-                type : "integer",
-                required : true, // SQL Data Constraints
-                foreignKey : "user" // SQL Data Constraints
-            },
-            website_url : {
-                type : "string",
-                required : true,
-                maxLength : 60
-            },
-            website_type : {
-                type : "string",
-                required : true
-            }
-        });
+    get(){
+        return ` 
+class ${this.name} extends Schema { 
+    constructor(context){
+        super(context);
+    }
 
-        this.addColumn("blog", "url", {
-            type : "string",
-            required : true
-        });
+    up(table){
+        ${this.up}
+    }
 
-        this.done();
+    down(table){
+        ${this.down}
+    }
+}
+module.exports = ${this.name};
+        `
     }
 
-    static down(){
-        this.dropTable("user");
+    alterColumn(){
+        if(type === "up"){
+            this.up += os.EOL + `     this.alterColumn(table.name, table.column);` 
+        }
+        else{
+            this.down += os.EOL + `     this.alterColumn(table.name, table.column);` 
+        }
+    }
+    createTable(){
+        if(type === "up"){
+            this.up += os.EOL + `     this.createTable(table.name);` 
+        }
+        else{
+            this.down += os.EOL + `     this.createTable(table.name);` 
+        }
+    }
 
-        this.dropColumn("blog", "url");
+    addColumn(type){
+        if(type === "up"){
+            this.up += os.EOL + `     this.addColumn(table.name, table.column);`
+        }
+        else{
+            this.down += os.EOL + `     this.addColumn(table.name, table.column);`
+        }
+    }
+    
+   
+    dropTable(type){
+        if(type === "up"){
+            this.down += os.EOL + `    this.droptable(table.name);`
+        }
+        else{
+            this.down += os.EOL + `    this.droptable(table.name);`
+        }
+    }
 
-        this.done();      
+    dropColumn(type){
+        if(type === "up"){
+            this.up += os.EOL + `     this.dropColumn(table.name, table.column);`
+        }
+        else{
+            this.down += os.EOL + `     this.dropColumn(table.name, table.column);`
+        }
     }
+
 }
 
-module.exports = Migration;
+module.exports = MigrationTemplate;
+

package/Migrations/migrations.js

@@ -1,57 +1,174 @@
-// version 1
+// version 0.0.3
+// learn more about seeding info -  https://www.pauric.blog/Database-Updates-and-Migrations-with-Entity-Framework/
+
 var fs = require('fs');
+var diff = require("deep-object-diff");
+var MigrationTemplate = require("./migrationTemplate");
+var globSearch = require("glob");
+
 // https://blog.tekspace.io/code-first-multiple-db-context-migration/
 
 // node masterrecord add-migration josh C:\Users\rbatista\Downloads\kollege\freshmen\app\models\context
 class Migrations{
 
-    EDMModelDiffer(snapShots, tableList){
-        new schemaList = []
-        const tableKeyList = Object.keys(tableList);
-        // loop through tables
-        for (const tableKey of tableKeyList) {
-            // check if table has already been migrated
-            var tableSnapShot = snapShots[tableKey];
-            if(tableSnapShot){
-                // check if we have the column in the sceama
-                const columnKeyList = Object.keys(tableKey);
-                // loop through tables
-                for (const columnKey of columnKeyList) {
-                    var newTable = {};
-                    if(tableSnapShot[columnKey]){
-
-                        /*
-                            id : {
-                                nullabale : true,
-                                type : string
-                            }
+    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
+            }
+    }
 
-                            id : {
-                                nullabale : true,
-                                type : int,
-                                unique : true
-                            }
-                        
-                        */
-                        // if we then check if we have all the same types
-                        // loop through schema list
-                        // check if we have the same in the context
-                        // if the same then check if if value is diffrent
-                        // then delete from context
-                        // after loop complete wahtever left in conext just push to object
+    createSnapShot(snap){
+        var migrationsDirectory = `${snap.executedLocation}/db/migrations`;
+        if (!fs.existsSync(migrationsDirectory)){
+            fs.mkdirSync(migrationsDirectory);
+        }
+    
+        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`,
+            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){
+            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);
                     }
-                    else{
-                        // if we dont have it then add it to the
-                        newTable[columnKey] = tableKey[columnKey];
-                        schemaList.push(newTable);
-                    }  
+                });
+            });
+
+            return tables;
+    }
+
+    findDeletedColumnsInTables(tables){
+            tables.forEach(function (item, index) {
+                var deletedColumn = null;
+                if(item.new && item.old){
+                    Object.keys(item.old).forEach(function (key) {
+                        var value = item.old[key].name;
+                        deletedColumn = null;
+                        Object.keys(item.new).forEach(function (newKey) {
+                            var newValue = item.new[newKey].name;
+                            if(value === newValue){
+                                deletedColumn = value;
+                            }
+                        });
+                        if(deletedColumn === null){
+                            item.deletedColumns.push(value);
+                        }
+                    });
                 }
-            }else{
-                schemaList.push(contextKeys[key]);
+            });
+            return 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));
             }
-            
            
-        }
+        });
+        return tables;
+    }
+
+    findNewColumnsInTables(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(newColumn === null){
+                            item.newColumns.push(value);
+                        }
+                    });
+                }
+            });
+            return tables;
+    }
+
+      
+    buildMigrationTemplate(name, oldSchema, newSchema){
+
+        var MT = new MigrationTemplate(name);
+        var tables = this.organizeSchemaByTables(oldSchema, newSchema);
+        tables = this.findNewColumnsInTables(tables);
+        tables = this.findDeletedColumnsInTables(tables);
+        tables = this.findUpdatedColumns(tables);
+        tables.forEach(function (item, index) {
+            // add new columns for table
+            item.newColumns.forEach(function (column, index) {
+                MT.addColumn();
+                MT.dropColumn("down");
+            });
+
+            item.deletedColumns.forEach(function (column, index) {
+                MT.dropColumn("up");
+                MT.addColumn("down");
+            });
+
+            item.updatedColumns.forEach(function (column, index) {
+                MT.alterColumn();
+                MT.alterColumn("down")
+            });
+
+            if(item.old === null){
+                MT.createTable();
+                MT.dropTable("down");
+
+            }
+            if(item.new === null){
+                MT.dropTable("up");
+                MT.createTable("down");
+            }
+
+        });
+
+       return MT.get();
+    
+
     }
 
     migrationCodeGenerator(name, column, migrationDate){

package/Migrations/schema.js

@@ -2,23 +2,43 @@
 var fs = require('fs');
 
 class Schema{
-
+    
+    constructor(settings){
+        this.settings = settings;
+    }
+    
     // create obj to convert into create sql
     addColumn(tableName, columnName, ){
 
         // add column to database
     }
 
+    createTable(name, columns){
+
+    }
+
     dropColumn(tableName, columnName){
         // drop column 
 
     }
 
-    createTable(name, columns){
+    dropTable(name){
 
     }
 
-    dropTable(name){
+    dropIndex(){
+
+    }
+//"dbo.People", "Location"
+    alterColumn(){
+
+    }
+
+    renameColumn(){
+
+    }
+
+    seed(){
 
     }
 
@@ -27,6 +47,7 @@ class Schema{
 
 
     }
+    
 }
 
 

package/Tools.js

@@ -4,6 +4,17 @@ class Tools{
         return entityList[name];
     }
 
+
+    // this will remove everthing from back slash amount
+    static removeBackwardSlashSection(string, amount, type){
+        type = type === undefined ? "\\" : type;
+        var stringArray =  string.split(type);
+        for(var i = 0; i < amount; i++){
+            stringArray.pop();
+        }
+        return stringArray.join(type);
+    }
+
     static removePrimarykeyandVirtual(currentModel, modelEntity){
         var newCurrentModel = Object.create(currentModel);
 

package/package.json

@@ -2,22 +2,24 @@
   "name": "masterrecord",
   "dependencies": {
     "better-sqlite3": "^7.6.2",
-    "commander": "^9.4.0"
+    "commander": "^9.4.0",
+    "glob" : "^8.0.3",
+    "deep-object-diff" : "^1.1.7"
   },
-  "version": "0.0.26",
+  "version": "0.0.28",
   "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": {
     "type": "git",
     "url": "git+https://github.com/Tailor/Masterrecord.git"
   },
-  "main": "./MasterRecord.js",
+  "main": "./migrations/cli.js",
   "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1"
   },
   "author": "Alexander Rich",
   "license": "ISC",
   "bin": {
-    "masterrecord": "migrations/cli.js"
+    "masterrecord": "./migrations/cli.js"
   }
 }

package/readme.md

@@ -0,0 +1 @@
+local install of CLI package run code in terminal - "npm install -g ./"