masterrecord 0.0.33 → 0.0.35

package/Entity/entityModel.js

@@ -17,7 +17,7 @@
 
 */
 
-// version 0.0.2
+// version 0.0.3
 class EntityModel {
     
     constructor(name){
@@ -137,9 +137,11 @@ class EntityModel {
         this.obj.foreignTable = foreignTable;
         this.obj.foreignKey = foreignKey;
         this.obj.isNavigational = true;
+        this.obj.nullable = false;
         return this;
     }
 
+    // DB must have a record or exception will be thrown unless set to nullable
     hasOne(foreignTable, foreignKey){
         if(foreignKey === undefined){
             foreignKey = `${this.obj.name.toLowerCase()}_id`;
@@ -148,6 +150,7 @@ class EntityModel {
         this.obj.foreignTable = foreignTable;
         this.obj.foreignKey = foreignKey;
         this.obj.isNavigational = true;
+        this.obj.nullable = false;
         return this;
     }
 

package/Entity/entityTrackerModel.js

@@ -1,3 +1,5 @@
+
+// version : 0.0.1
 var tools =  require('../Tools');
 class EntityTrackerModel {
 
@@ -108,21 +110,13 @@ class EntityTrackerModel {
                     
                     if(currentEntity[entityField].type === "belongsTo"){
                         if(currentEntity[entityField].lazyLoading){
-                            var priKey = tools.getPrimaryKeyObject(this.__entity);
-                            var currentValue = this.__proto__[`_${entityField}`];
-                            if(currentValue){
-                                // CHECK to see if you got the info already
-                                if(typeof currentValue === 'object'){
-                                    currentValue = currentValue[priKey];
-                                }    
-                            }
-                            else{
-                                var idValue = currentEntity[entityField].foreignTable;
-                                currentValue = this.__proto__[`_${idValue}`];
-                            }
+                             // TODO: UPDATE THIS CODE TO USE SOMETHING ELSE - THIS WILL NOT WORK WHEN USING DIFFERENT DATABASES BECAUSE THIS IS USING SQLITE CODE. 
+                        
+                            var priKey = tools.getPrimaryKeyObject(ent.__entity);
 
-                            //var modelValue = ent.raw(`select * from ${ent.__entity.__name} where ${priKey} = ${ currentValue }`).single();
-                            var modelValue = ent.where(`r => r. ${priKey} == ${ currentValue }`)
+                            var idValue = currentEntity[entityField].foreignKey;
+                            var currentValue = this.__proto__[`_${idValue}`];
+                            var modelValue = ent.where(`r => r.${priKey} == ${ currentValue }`).single();
                             this[entityField] = modelValue;
                         }
                         else{

package/Masterrecord.js

@@ -1,7 +1,7 @@
 
 // https://github.com/kriasoft/node-sqlite
 // https://www.learnentityframeworkcore.com/dbset/deleting-data
-// version 1.0.19
+// version 1.0.20
 var context = require("./context");
 var schema = require("./Migrations/schema");
 

package/Migrations/cli.js

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 
-// version 0.0.5
+// version 0.0.7
 // 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,7 +16,7 @@ const [,, ...args] = process.argv
 
 program
   .version('0.0.2')
-  .option('-v, --version', '0.0.33') 
+  .option('-v, --version', '0.0.34') 
   .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.
@@ -46,7 +46,7 @@ program
   });
 
   // Instructions : to run command you must go to folder where migration file is located.
-  program
+  program //// TODO ---- WHY MIGRATION IS CREATING ADD COLUMSN AS WELL AS NEW TABLE
   .command('add-migration <name> <contextFileName>')
   .alias('am')
   .action(function(name, contextFileName){
@@ -62,7 +62,7 @@ program
           var contextSnapshot = require(files[0]);
           var context = require(contextSnapshot.contextLocation);
           var contextInstance = new context();
-          var newEntity = migration.template(name, contextSnapshot.schema, contextInstance .__entities);
+          var 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) {
@@ -103,13 +103,12 @@ program
              });
  
              var mFile = mFiles[0];
-             var migrationFile = require(mFile);
+             var migrationProjectFile = 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 newMigrationProjectInstance = new migrationProjectFile(context);
+             var tableObj = migration.buildUpObject(contextSnapshot.schema, contextInstance.__entities);
+             newMigrationProjectInstance.up(tableObj);
             
              var snap = {
                file : contextSnapshot.contextLocation,

package/Migrations/migrationSQLiteQuery.js

@@ -1,5 +1,5 @@
 
-// verison 0.0.3
+// verison 0.0.5
 class migrationSQLiteQuery {
 
     #tempTableName = "_temp_alter_column_update"
@@ -60,12 +60,12 @@ class migrationSQLiteQuery {
 
     alterColumn(fullTable, table){
         if(table){
-            table.newName = this.tempTableName;
+            table.newName = this.#tempTableName;
             return {
                 1 : this.renameTable(table),
-                2 : this.createTable(table.tableName, fullTable),
+                2 : this.createTable(fullTable),
                 3 : this.insertInto(table.tableName, fullTable),
-                4 : this.dropTable(this.tempTableName)
+                4 : this.dropTable(this.#tempTableName)
             }
         }
         else{
@@ -100,7 +100,7 @@ class migrationSQLiteQuery {
 
     insertInto(name, table){
         return `INSERT INTO ${name} (${this.#getTableColumns(table)})
-        SELECT ${this.#getTableColumns(table)} FROM ${this.tempTableName}`;
+        SELECT ${this.#getTableColumns(table)} FROM ${this.#tempTableName}`;
     }
 
     createTable(table){
@@ -110,21 +110,21 @@ class migrationSQLiteQuery {
                 queryVar += `${this.#columnMapping(table[key])}, `;
             }
         }
-     
+    
         return `CREATE TABLE ${table.__name} (${queryVar.replace(/,\s*$/, "")});`;
 
             /*
-            INTEGER PRIMARY KEY AUTOINCREMENT
-                all these are equal to interger
-            INT
-            INTEGER
-            TINYINT
-            SMALLINT
-            MEDIUMINT
-            BIGINT
-            UNSIGNED BIG INT
-            INT2
-            INT8 
+                INTEGER PRIMARY KEY AUTOINCREMENT
+                    all these are equal to interger
+                INT
+                INTEGER
+                TINYINT
+                SMALLINT
+                MEDIUMINT
+                BIGINT
+                UNSIGNED BIG INT
+                INT2
+                INT8 
             */
     }
 

package/Migrations/migrations.js

@@ -1,4 +1,4 @@
-// version 0.0.5
+// version 0.0.7
 // learn more about seeding info -  https://www.pauric.blog/Database-Updates-and-Migrations-with-Entity-Framework/
 
 var fs = require('fs');
@@ -186,22 +186,22 @@ class Migrations{
     }
 
     //
-    up(oldSchema, newSchema){
+    buildUpObject(oldSchema, newSchema){
         var tableObj = {}
         var tables = this.#buildMigrationObject(oldSchema, newSchema); 
         tables.forEach(function (item, index) {
                     // add new columns for table
                     var columnInfo = tables[index];
                     
+                    item.newTables.forEach(function (column, ind) {
+                        tableObj[item.name] = columnInfo.new;
+                    });
+
                     item.newColumns.forEach(function (column, ind) {
                         columnInfo.new[column].tableName = item.name;
                         tableObj[column] = columnInfo.new[column];
                     });
 
-                    item.newTables.forEach(function (column, ind) {
-                        tableObj[item.name] = columnInfo.new;
-                    });
-
                     item.deletedColumns.forEach(function (column, ind) {
                         columnInfo.old[column].tableName = item.name;
                         tableObj[column] = columnInfo.old[column];
@@ -218,24 +218,35 @@ class Migrations{
 
                     tableObj.___table = item;
                 });
-                return tableObj;
+        return tableObj;
     }
 
     template(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("up", column, item.name);
-                MT.dropColumn("down", column, item.name);
-            });
+            if(item.old === null){
+                MT.createTable("up", column, item.name);
+                MT.dropTable("down", column, item.name);
+            }
+            
+            if(item.new === null){
+                MT.dropTable("up", column, item.name);
+                MT.createTable("down", column, item.name);
+            }
 
             item.newTables.forEach(function (column, ind) {
                 MT.createTable("up", item.name);
                 MT.dropTable("down", item.name);
             });
 
+            // add new columns for table
+            item.newColumns.forEach(function (column, index) {
+                MT.addColumn("up", column, item.name);
+                MT.dropColumn("down", column, item.name);
+            });
+
             item.deletedColumns.forEach(function (column, index) {
                 MT.dropColumn("up", column, item.name);
                 MT.addColumn("down",column, item.name);
@@ -249,16 +260,6 @@ class Migrations{
                 }
             });
 
-            if(item.old === null){
-                MT.createTable("up", column, item.name);
-                MT.dropTable("down", column, item.name);
-
-            }
-            if(item.new === null){
-                MT.dropTable("up", column, item.name);
-                MT.createTable("down", column, item.name);
-            }
-
         });
 
        return MT.get();

package/QueryLanguage/queryMethods.js

@@ -1,6 +1,5 @@
-// ALL THIS SHOULD DO IS BUILD A SQL QUERY
-// version 1.0.222
-// TODO: change name of queryManager to select manager;
+
+// version 0.0.7
 var entityTrackerModel = require('masterrecord/Entity/entityTrackerModel');
 var tools = require('masterrecord/Tools');
 var queryScript = require('masterrecord/QueryLanguage/queryScript');
@@ -45,12 +44,91 @@ class queryMethods{
         this.__queryObject.reset();
     }
 
-    raw(query){
 
+    // do join on two tables = inner join
+    join(){
+
+    }
+
+    groupBy(){
+        
+    }
+
+    contains(){
+            // https://entityframework.net/knowledge-base/3491721/linq-to-entities---where-in-clause-in-query
+    }
+
+    // do join on two tables = inner join
+    _____leftJoin(){
+
+    }
+
+    ______orderByCount(query,  ...args){
+        var str = query.toString();
+        if(args){
+            for(let argument in args){
+                var item = args[argument];
+                str = str.replace("$$", item);
+            }
+        }
+        this.__queryObject.orderByCount(str, this.__entity.__name);
+        return this;
+    }
+
+    ______orderByCountDescending(query,  ...args){
+        var str = query.toString();
+        if(args){
+            for(let argument in args){
+                var item = args[argument];
+                str = str.replace("$$", item);
+            }
+        }
+        this.__queryObject.orderByCountDesc(str, this.__entity.__name);
+        return this;
+    }
+
+    orderBy(query,  ...args){
+        var str = query.toString();
+        if(args){
+            for(let argument in args){
+                var item = args[argument];
+                str = str.replace("$$", item);
+            }
+        }
+        this.__queryObject.orderBy(str, this.__entity.__name);
+        return this;
+    }
+
+    orderByDescending(query,  ...args){
+        var str = query.toString();
+        if(args){
+            for(let argument in args){
+                var item = args[argument];
+                str = str.replace("$$", item);
+            }
+        }
+        this.__queryObject.orderByDesc(str, this.__entity.__name);
+        return this;
+    }
+
+    raw(query){
         this.__queryObject.raw(query);
         return this;
     }
 
+    /* WHERE and AND work together its a way to add to the WHERE CLAUSE DYNAMICALLY */
+    and(query,  ...args){
+        var str = query.toString();
+        if(args){
+            for(let argument in args){
+                var item = args[argument];
+                str = str.replace("$$", item);
+            }
+        }
+        this.__queryObject.and(str, this.__entity.__name);
+        return this;
+    }
+
     where(query,  ...args){
         var str = query.toString();
         if(args){
@@ -90,65 +168,68 @@ class queryMethods{
         return this;
     }
 
-
-
-    // do join on two tables = inner join
-    join(){
-
-    }
-
-    skip(){
-
-    }
-
-    limit(){
-
+    take(number){
+        this.__queryObject.script.take = number;
+        return this;
     }
 
-    oderBy(){
-
+    skip(number){
+        this.__queryObject.script.skip = number;
+        return this;
     }
 
-    groupBy(){
-        
-    }
+    
+    // ------------------------------- FUNCTIONS THAT MAKE THE SQL CALL START FROM HERE ON -----------------------------------------------------
+    // ---------------------------------------------------------------------------------------------------------------------------------------
 
-    contains(){
-            // https://entityframework.net/knowledge-base/3491721/linq-to-entities---where-in-clause-in-query
-    }
+    count(query,  ...args){
+        if(query){
+            var str = query.toString();
+            if(args){
+                for(let argument in args){
+                    var item = args[argument];
+                    str = str.replace("$$", item);
+                }
+            }
+            this.__queryObject.count(str, this.__entity.__name);
+        }
 
-    count(){
-        // trying to match string select and relace with select Count(*);
-        var entityValue = this.__context._SQLEngine.getCount(this.__queryObject, this.__entity, this.__context);
-        var val = entityValue[Object.keys(entityValue)[0]];
-        this.__reset();
-        return val;
+        if(this.__context.isSQLite){
+            // trying to match string select and relace with select Count(*);
+            var entityValue = this.__context._SQLEngine.getCount(this.__queryObject, this.__entity, this.__context);
+            var val = entityValue[Object.keys(entityValue)[0]];
+            this.__reset();
+            return val;
+        }
     }
 
     single(){
-        var entityValue = this.__context._SQLEngine.get(this.__queryObject.script, this.__entity, this.__context);
-        var sing = this.__singleEntityBuilder(entityValue, this._queryBuilder);
-        this.__reset();
-        return sing;
+        if(this.__context.isSQLite){
+            var entityValue = this.__context._SQLEngine.get(this.__queryObject.script, this.__entity, this.__context);
+            var sing = this.__singleEntityBuilder(entityValue, this._queryBuilder);
+            this.__reset();
+            return sing;
+        }
     }
 
     toList(){
-        var entityValue = this.__context._SQLEngine.all(this.__queryObject.script, this.__entity, this.__context);
-        var toLi = this.__multipleEntityBuilder(entityValue, this._queryBuilder);
-        this.__reset();
-        return toLi;
-    }
-
-    asQueryable(){
-        // returns the sql created and does not make a call to DB
+        if(this.__context.isSQLite){
+            var entityValue = this.__context._SQLEngine.all(this.__queryObject.script, this.__entity, this.__context);
+            var toLi = this.__multipleEntityBuilder(entityValue, this._queryBuilder);
+            this.__reset();
+            return toLi;
+        }
     }
 
+      // ------------------------------- FUNCTIONS THAT UPDATE SQL START FROM HERE  -----------------------------------------------------
+    // ---------------------------------------------------------------------------------------------------------------------------------------
     add(entityValue){
         // This will call context API to REMOVE entity to update list
         tools.clearAllProto(entityValue);
         entityValue.__state = "insert";
         entityValue.__entity = this.__entity;
         entityValue.__context = this.__context;
+        entityValue.__name = this.__entity.__name;
         this.__context.__track(entityValue);
     }
     
@@ -158,6 +239,14 @@ class queryMethods{
         entityValue.__context = this.__context;
     }
 
+    removeRange(entityValues){
+        for (const property in entityValues) {
+            entityValues[property].__state = "delete";
+            entityValues[property].__entity = this.__entity;
+            entityValues[property].__context = this.__context;
+        }
+    }
+
     track(entityValue){
         entityValue.__state = "track";
         tools.clearAllProto(entityValue);

package/QueryLanguage/queryScript.js

@@ -1,4 +1,4 @@
-// version 1.0.1
+// version 0.0.2
 
 const LOG_OPERATORS_REGEX = /(\|\|)|(&&)/;
 var tools =  require('../Tools');
@@ -10,10 +10,15 @@ class queryScript{
     script = {
         select : false,
         where: false,
+        and : [],
         include : [],
         raw: false,
         entity : "",
-        entityMap : []
+        entityMap : [],
+        take : 0,
+        skip: 0,
+        orderBy : false,
+        orderByDesc : false
     };
 
 
@@ -21,10 +26,15 @@ class queryScript{
         this.script = {
             select : false,
             where: false,
+            and : [],
             include : [],
             raw: false,
             entity : "",
-            entityMap : []
+            entityMap : [],
+            take : 0,
+            skip: 0,
+            orderBy : false,
+            orderByDesc : false
         };
     }
 
@@ -37,7 +47,23 @@ class queryScript{
         return this.script;
     }
 
+    orderBy(text, entityName){
+        this.buildScript(text, "orderBy", this.script, entityName);
+        return this.script;
+    }
+
+    orderByDesc(text, entityName){
+        this.buildScript(text, "orderByDesc", this.script, entityName);
+        return this.script;
+    }
+
+    and(text, entityName){
+        this.buildScript(text, "and", this.script, entityName);
+        return this.script;
+    }
+
     where(text, entityName){
+
         this.buildScript(text, "where", this.script, entityName);
         return this.script;
     }
@@ -52,13 +78,9 @@ class queryScript{
         return this.script;
     }
 
-    count(queryString){
-        var matched = queryString.match(/(?<=select)(.*?)from/gmi );
-        matched[0] = matched[0].replace("from", "");
-        var cleanQuery = queryString.replace(/^(.*?)from/gmi, "");
-        var str = `Select Count(${matched[0]}) from ${cleanQuery}`
-
-        return str;
+    count(text, entityName){
+        this.buildScript(text, "count", this.script, entityName);
+        return this.script;
     }
 
     buildScript(text, type, obj, entityName){
@@ -96,7 +118,7 @@ class queryScript{
             }
 
             this.describeExpressionParts(cachedExpr[entityName], cachedExpr.selectFields[0], obj.entityMap);
-            if(type === "include"){
+            if(type === "include" || type === "and"){
                 obj[type].push(cachedExpr)
             }
             else{
@@ -130,8 +152,8 @@ class queryScript{
                 if (!fields.includes(field)) fields.push(field);
             });
 
-            desc.expr = exprStr.trim()
-            desc.selectFields = fields
+            desc.expr = exprStr.trim();
+            desc.selectFields = fields;
             return desc;
         }
         else{

package/QueryLanguage/selectManager.js

@@ -0,0 +1,66 @@
+
+// // version 0.0.2
+
+// class selectManager{
+//     constructor( query) {
+
+//         /*
+//             queryObject
+//             {
+//                 "where": where user.id = 1
+//                 "raw": "select * from tablename where user.id = 2" OR false,
+//                 "builder": builderObject,
+//                 "select" : "*",
+//                 "from" : from tablename
+//             }
+//         */
+//         this._query = query;
+//         this._queryBuilder = query.builder;
+//         this._context = query.builder.__context;
+//     }
+    
+//     single(){
+//         var entityValue = this._context._SQLEngine.get(this._query.getScript());
+//         var sing = this._queryBuilder.__execute(entityValue, this._queryBuilder);
+//         return sing;
+//     }
+
+//     //
+//     select(query){
+//        // this will come after the where
+//        this._query.select = "select " + query;
+//        return this;
+//     }
+    
+//     count(){
+//         // trying to match string select and relace with select Count(*);
+//         var res = this._query.select.replace("select *", "select Count(*)");
+//         var entityValue = this._context._SQLEngine.get(res);
+//         var val = entityValue[Object.keys(entityValue)[0]];
+//         return val;
+//     }
+
+//     toList(){
+//         var entityValue = this._context._SQLEngine.all(this._query);
+//         var toLi = this._queryBuilder.__executeList(entityValue, this._queryBuilder);
+//         return toLi;
+//     }
+
+// }
+
+// module.exports = selectManager;
+
+
+/*
+
+LINQ Extension Methods
+First()
+FirstOrDefault()
+SingleOrDefault()
+Count()
+Min()
+Max()
+Last()
+LastOrDefault()
+Average()
+*/