masterrecord 0.0.34 → 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/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()
+*/

package/SQLLiteEngine.js

@@ -1,4 +1,4 @@
-// Version 0.0.1
+// Version 0.0.6
 var tools =  require('masterrecord/Tools');
 
 class SQLLiteEngine {
@@ -36,7 +36,12 @@ class SQLLiteEngine {
                 queryString.query = query.raw;
             }
             else{
-                queryString = this.buildQuery(query, entity, context);
+                if(typeof query === 'string'){
+                    queryString.query = query;
+                }
+                else{
+                    queryString = this.buildQuery(query, entity, context);
+                }
             }
             if(queryString.query){
                 console.log("SQL:", queryString.query);
@@ -58,10 +63,14 @@ class SQLLiteEngine {
                 queryString.query = query.raw;
             }
             else{
-                queryString = this.buildQuery(query, entity, context);
+                if(query.count === undefined){
+                    query.count = "none";
+                }
+                queryString.entity = this.getEntity(entity.__name, query.entityMap);
+                queryString.query = `SELECT ${this.buildCount(query, entity)} ${this.buildFrom(query, entity)} ${this.buildWhere(query, entity)}`
             }
             if(queryString.query){
-                var queryCount = queryObject.count(queryString.query)
+                var queryCount = queryString.query
                 console.log("SQL:", queryCount );
                 var queryReturn = this.db.prepare(queryCount ).get();
                 return queryReturn;
@@ -80,6 +89,7 @@ class SQLLiteEngine {
                 selectQuery.query = query.raw;
             }
             else{
+              
                 selectQuery = this.buildQuery(query, entity, context);
             }
             if(selectQuery.query){
@@ -94,17 +104,49 @@ class SQLLiteEngine {
         }
     }
 
+    changeNullQuery(query){
+        if(query.where){
+            var whereClaus;
+            whereClaus = query.where.expr.replace("=== null", "is null");
+            if(whereClaus === query.where.expr){
+                whereClaus = query.where.expr.replace("!= null", "is not null");
+            }
+            query.where.expr = whereClaus;
+        }
+
+    }
+
+    buildCount(query, mainQuery){
+            var entity = this.getEntity(query.parentName, query.entityMap);
+            if(query.count){
+                if(query.count !== "none"){
+                    return `COUNT(${entity}.${query.count.selectFields[0]})`
+                }
+                else{
+                    return `COUNT(*)`
+                }             
+            }
+            else{
+                return ""
+            }
+    }
 
-    buildQuery(query, entity, context){
+    buildQuery(query, entity, context, limit){
 
         var queryObject = {};
         queryObject.entity = this.getEntity(entity.__name, query.entityMap);
         queryObject.select = this.buildSelect(query, entity);
+        queryObject.count = this.buildCount(query, entity);
         queryObject.from = this.buildFrom(query, entity);
         queryObject.include = this.buildInclude(query, entity, context, queryObject);
         queryObject.where = this.buildWhere(query, entity);
+        queryObject.and = this.buildAnd(query, entity);
+        queryObject.take = this.buildTake(query);
+        queryObject.skip = this.buildSkip(query);
+        queryObject.orderBy = this.buildOrderBy(query);
 
-        var queryString = `${queryObject.select} ${queryObject.from} ${queryObject.include} ${queryObject.where}`;
+
+        var queryString = `${queryObject.select} ${queryObject.count} ${queryObject.from} ${queryObject.include} ${queryObject.where} ${queryObject.and} ${queryObject.orderBy} ${queryObject.take} ${queryObject.skip}`;
         return { 
                 query : queryString,
                 entity : this.getEntity(entity.__name, query.entityMap)
@@ -112,8 +154,108 @@ class SQLLiteEngine {
 
     }
 
+    buildOrderBy(query){
+        // ORDER BY column1, column2, ... ASC|DESC;
+        var $that = this;
+        var orderByType = "ASC";
+        var orderByEntity = query.orderBy;
+        var strQuery = "";
+        if(orderByEntity === false){
+            orderByType = "DESC";
+            orderByEntity = query.orderByDesc;
+        }
+        if(orderByEntity){
+            var entity = this.getEntity(query.parentName, query.entityMap);
+            var fieldList = "";
+            for (const item in orderByEntity.selectFields) {
+                fieldList += `${entity}.${orderByEntity.selectFields[item]}, `;
+            };
+            fieldList = fieldList.replace(/,\s*$/, "");
+            strQuery = "ORDER BY";
+            strQuery += ` ${fieldList} ${orderByType}`;
+        }
+        return strQuery;
+    }
+
+    buildTake(query){
+        if(query.take){
+            return `LIMIT ${query.take}`
+        }
+        else{
+            return "";
+        }
+    }
+
+    buildSkip(query){
+        if(query.skip){
+            return `OFFSET ${query.skip}`
+        }
+        else{
+            return "";
+        }
+    }
+
+    buildAnd(query, mainQuery){
+        // loop through the AND
+        // loop update ther where .expr
+        var andEntity = query.and;
+        var strQuery = "";
+        var $that = this;
+        var str = "";
+
+        if(andEntity){
+            var entity = this.getEntity(query.parentName, query.entityMap);
+            var andList = [];
+            for (let entityPart in andEntity) { // loop through list of and's
+                    var itemEntity = andEntity[entityPart]; // get the entityANd
+                for (let table in itemEntity[query.parentName]) { // find the main table
+                     var item = itemEntity[query.parentName][table];
+                    for (let exp in item.expressions) {
+                        var field = tools.capitalizeFirstLetter(item.expressions[exp].field);
+                        if(mainQuery[field]){
+                            if(mainQuery[field].isNavigational){
+                                entity = $that.getEntity(field, query.entityMap);
+                                field = item.fields[1];
+                            }
+                        }
+                        if(item.expressions[exp].arg === "null"){
+                            if(item.expressions[exp].func === "="){
+                                item.expressions[exp].func = "is"
+                            }
+                            if(item.expressions[exp].func === "!="){
+                                item.expressions[exp].func = "is not"
+                            }
+                        }
+                        if(strQuery === ""){
+                            if(item.expressions[exp].arg === "null"){
+                                strQuery = `${entity}.${field}  ${item.expressions[exp].func} ${item.expressions[exp].arg}`;
+                            }else{
+                                strQuery = `${entity}.${field}  ${item.expressions[exp].func} '${item.expressions[exp].arg}'`;
+                            }
+                        }
+                        else{
+                            if(item.expressions[exp].arg === "null"){
+                                strQuery = `${strQuery} and ${entity}.${field}  ${item.expressions[exp].func} ${item.expressions[exp].arg}`;
+                            }else{
+                                strQuery = `${strQuery} and ${entity}.${field}  ${item.expressions[exp].func} '${item.expressions[exp].arg}'`;
+                            }
+                           
+                        }
+                    }
+                    andList.push(strQuery);
+                }
+            }
+        }
+        
+        if(andList.length > 0){
+            str = `and ${andList.join(" and ")}`;
+        }
+        return str
+    }
+
     buildWhere(query, mainQuery){
         var whereEntity = query.where;
+
         var strQuery = "";
         var $that = this;
         if(whereEntity){
@@ -128,11 +270,28 @@ class SQLLiteEngine {
                                 field = item.fields[1];
                             }
                         }
+                        if(item.expressions[exp].arg === "null"){
+                            if(item.expressions[exp].func === "="){
+                                item.expressions[exp].func = "is"
+                            }
+                            if(item.expressions[exp].func === "!="){
+                                item.expressions[exp].func = "is not"
+                            }
+                        }
                         if(strQuery === ""){
-                            strQuery = `WHERE ${entity}.${field}  ${item.expressions[exp].func} '${item.expressions[exp].arg}'`;
+                            if(item.expressions[exp].arg === "null"){
+                                strQuery = `WHERE ${entity}.${field}  ${item.expressions[exp].func} ${item.expressions[exp].arg}`;
+                            }else{
+                                strQuery = `WHERE ${entity}.${field}  ${item.expressions[exp].func} '${item.expressions[exp].arg}'`;
+                            }
                         }
                         else{
-                            strQuery = `${strQuery} and ${entity}.${field}  ${item.expressions[exp].func} '${item.expressions[exp].arg}'`;
+                            if(item.expressions[exp].arg === "null"){
+                                strQuery = `${strQuery} and ${entity}.${field}  ${item.expressions[exp].func} ${item.expressions[exp].arg}`;
+                            }else{
+                                strQuery = `${strQuery} and ${entity}.${field}  ${item.expressions[exp].func} '${item.expressions[exp].arg}'`;
+                            }
+                           
                         }
                     }
                 }
@@ -250,7 +409,7 @@ class SQLLiteEngine {
     getEntity(name, maps){
         for (let item in maps) {
             var map = maps[item];
-            if(tools.capitalizeFirstLetter(name) === map.name){
+            if(tools.capitalizeFirstLetter(name) === tools.capitalizeFirstLetter(map.name)){
                 return map.entity
             }
         }
@@ -264,21 +423,16 @@ class SQLLiteEngine {
         for (var ent in entity) {
                 if(!ent.startsWith("_")){
                     if(!entity[ent].foreignKey){
-                        if(entity[ent].relationshipTable){
-                            if($that.chechUnsupportedWords(entity[ent].relationshipTable)){
-                                entitiesList.push(`'${entity[ent].relationshipTable}'`);
-                            }
-                            else{
-                                entitiesList.push(entity[ent].relationshipTable);
-                            }
+                        if($that.chechUnsupportedWords(ent)){
+                            entitiesList.push(`'${ent}'`);
                         }
                         else{
-                            if($that.chechUnsupportedWords(ent)){
-                                entitiesList.push(`'${ent}'`);
-                            }
-                            else{
-                                entitiesList.push(ent);
-                            }
+                            entitiesList.push(ent);
+                        }
+                    }
+                    else{
+                        if(entity[ent].type === 'belongsTo'){
+                            entitiesList.push(`${entity[ent].foreignKey}`);
                         }
                     }
                 }
@@ -354,7 +508,7 @@ class SQLLiteEngine {
                 if((fieldColumn !== undefined && fieldColumn !== null && fieldColumn !== "" ) && typeof(fieldColumn) !== "object"){
                     switch(modelEntity[column].type){
                         case "belongsTo" :
-                            column = modelEntity[column].relationshipTable === undefined ? column : modelEntity[column].relationshipTable;
+                            column = modelEntity[column].foreignKey === undefined ? column : modelEntity[column].foreignKey;
                         break;
                         case "string" : 
                             fieldColumn = `'${$that._santizeSingleQuotes(fields[column])}'`;
@@ -368,6 +522,24 @@ class SQLLiteEngine {
                     values = values === null ? `${fieldColumn},` : `${values} ${fieldColumn},`;
 
                 }
+                else{
+                    switch(modelEntity[column].type){
+                        case "belongsTo" :
+                            var fieldObject = tools.findTrackedObject(fields.__context.__trackedEntities, column );
+                            if( Object.keys(fieldObject).length > 0){
+                                var primaryKey = tools.getPrimaryKeyObject(fieldObject.__entity);
+                                fieldColumn = fieldObject[primaryKey];
+                                column = modelEntity[column].foreignKey;
+                                columns = columns === null ? `'${column}',` : `${columns} '${column}',`;
+                                values = values === null ? `${fieldColumn},` : `${values} ${fieldColumn},`;
+                            }else{
+                                console.log("Cannot find belings to relationship")
+                            }
+    
+                        break;
+                    }
+                
+                }
             }
         }
         return {tableName: modelEntity.__name, columns: columns.replace(/,\s*$/, ""), values: values.replace(/,\s*$/, "")};

package/Tools.js

@@ -1,10 +1,10 @@
+// Version 0.0.1
 class Tools{
 
     static findEntity(name, entityList){
         return entityList[name];
     }
 
-
     // this will remove everthing from back slash amount
     static removeBackwardSlashSection(string, amount, type){
         type = type === undefined ? "\\" : type;
@@ -50,6 +50,15 @@ class Tools{
         return new type(validModel, classModel);
     }
 
+    static findTrackedObject(obj, name){
+        for (const property in obj) {
+            if(obj[property].__name === name){
+                return obj[property];
+            }
+        }
+        return {};
+    }
+
     static clearAllProto(proto){
         if(proto.__proto__ ){
             proto.__proto__ = null;

package/context.js

@@ -1,4 +1,4 @@
-// Version 0.0.3
+// Version 0.0.5
 
 var modelBuilder  = require('./Entity/EntityModelBuilder');
 var query = require('masterrecord/QueryLanguage/queryMethods');
@@ -21,7 +21,7 @@ class context {
     __relationshipModels = [];
     __enviornment = "";
     __name = "";
-    isSQite = false;
+    isSQLite = false;
     isMySQL = false;
 
     constructor(){
@@ -80,8 +80,6 @@ class context {
         }
     }
 
-
-
     __clearErrorHandler(){
         this._isModelValid = {
             isValid: true,
@@ -123,7 +121,7 @@ class context {
     }
 
     useSqlite(rootFolderLocation){
-        this.isSQite = true;
+        this.isSQLite = true;
         var root =  process.cwd();
         var envType = this.__enviornment;
         var contextName = this.__name;
@@ -181,41 +179,47 @@ class context {
     saveChanges(){
         try{
             var tracked = this.__trackedEntities;
-            // start transaction
-            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;
-                        } 
+            if(tracked.length > 0){
+                // start transaction
+                if(this.isSQLite){
+                    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();
+            }
+            else{
+                console.log("save changes has no tracked entities");
             }
         }
         
@@ -233,12 +237,11 @@ class context {
 
 
     _execute(query){
-        if(this.isSQite){
+        if(this.isSQLite){
             this._SQLEngine._execute(query);
         }
     }
 
-    // TODO: WHY WE HAVE DOUBLE TRACKED OBJECTS - LOOP THROUGH ALL TRACKED OBJECTS
     __track(model){
         this.__trackedEntities.push(model);
         return model;

package/deleteManager.js

@@ -1,5 +1,5 @@
+// version 0.0.2
 var tools =  require('./Tools');
-
 class DeleteManager{
     constructor(sqlEngine, entities){
         this._SQLEngine = sqlEngine;
@@ -24,7 +24,17 @@ class DeleteManager{
             for (const property of entityKeys) {
                 // cascade delete
                 if(currentModel.__entity[property].type === "hasOne" || currentModel.__entity[property].type === "hasMany"){
-                    $that.cascadeDelete( currentModel[property]);
+                    var curModel = currentModel[property];
+                    if(curModel === null){
+                     // check if state is nullable - if so and nothing comes back dont call cascadeDelete
+                     var prp = currentModel.__entity[property];
+                     if(!prp.nullable){
+                        throw "No relationship record found - please set hasOne or hasMany to nullable. "
+                     }
+                    }
+                    else{
+                        $that.cascadeDelete( currentModel[property]);
+                    }
                 }
             }
             this._SQLEngine.delete(currentModel);

package/insertManager.js

@@ -1,7 +1,9 @@
 
+// version 0.0.4
 var tools =  require('./Tools');
+
 class InsertManager {
-// TODO: WE are using the relationshipTable and the object name stick to one so that hasMany doesnt have to give a name
+
     constructor(sqlEngine, errorModel, allEntities ){
         this._SQLEngine = sqlEngine;
         this._errorModel = errorModel;
@@ -80,7 +82,7 @@ class InsertManager {
             if(modelEntity[entity].type === "belongsTo"){
                 var foreignKey = modelEntity[entity].foreignKey === undefined ? modelEntity[entity].name : modelEntity[entity].foreignKey;
                 var newPropertyModel = currentModel[foreignKey];
-                // check if model is a value because if so then skip we dont need to make an ajax call
+                // check if model is a an object. If so insert the child first then the parent. 
                 if(typeof newPropertyModel === 'object'){
                     newPropertyModel.__entity = tools.getEntity(entity, $that._allEntities);
                     var propertyCleanCurrentModel = tools.removePrimarykeyandVirtual(newPropertyModel, newPropertyModel.__entity);
@@ -110,11 +112,11 @@ class InsertManager {
                 }
             
                 // SKIP belongs too
-                if(currentEntity.type !== "belongsTo"){
+                if(currentEntity.type !== "belongsTo" && currentEntity.type !== "hasMany"){
                     // primary is always null in an insert so validation insert must be null
                     if(currentEntity.nullable === false && !currentEntity.primary){
                         // if it doesnt have a get method then call error
-                        if(currentEntity.get === undefined){
+                        if(currentEntity.set === undefined){
                             if(currentModel[entity] === undefined || currentModel[entity] === null || currentModel[entity] === "" ){
                                 this._errorModel.isValid = false;
                                 var errorMessage = `Entity ${currentModel.__entity.__name} column ${entity} is a required Field`;
@@ -123,7 +125,7 @@ class InsertManager {
                             }
                         }
                         else{
-                            currentRealModel[entity] = currentEntity.get(currentModel[entity]);
+                            currentRealModel[entity] = currentEntity.set(currentModel[entity]);
                         }
                     }
                 }

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "masterrecord",
   "dependencies": {
-    "better-sqlite3": "^7.6.2",
-    "commander": "^9.4.0",
-    "glob" : "^8.0.3",
-    "deep-object-diff" : "^1.1.7"
+    "better-sqlite3": "^8.6.0",
+    "commander": "^11.0.0",
+    "glob" : "^10.3.4",
+    "deep-object-diff" : "^1.1.9"
   },
-  "version": "0.0.34",
+  "version": "0.0.35",
   "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/QueryLanguage/queryManager.js

@@ -1,66 +0,0 @@
-// ALL THIS SHOULD DO IS BUILD A SQL QUERY
-// version 1.0.1
-
-class queryManager{
-    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 = queryManager;
-
-
-/*
-
-LINQ Extension Methods
-First()
-FirstOrDefault()
-SingleOrDefault()
-Count()
-Min()
-Max()
-Last()
-LastOrDefault()
-Average()
-*/