masterrecord 0.0.33 → 0.0.35

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.1
+// Version 0.0.5
 
 var modelBuilder  = require('./Entity/EntityModelBuilder');
 var query = require('masterrecord/QueryLanguage/queryMethods');
@@ -8,7 +8,7 @@ var MYSQLEngine = require('masterrecord/MYSQLEngine');
 var insertManager = require('./InsertManager');
 var deleteManager = require('./DeleteManager');
 var globSearch = require("glob");
-
+var fs = require('fs');
 
 class context {
     _isModelValid = {
@@ -21,7 +21,7 @@ class context {
     __relationshipModels = [];
     __enviornment = "";
     __name = "";
-    isSQite = false;
+    isSQLite = false;
     isMySQL = false;
 
     constructor(){
@@ -41,6 +41,7 @@ class context {
     */
     __SQLiteInit(env, sqlName){
         try{
+           
             const sqlite3 = require(sqlName);
             let DBAddress = env.completeConnection;
             var db = new sqlite3(DBAddress, env);
@@ -65,6 +66,7 @@ class context {
           */
     __mysqlInit(env, sqlName){
         try{
+            
             const mysql = require(sqlName);
             const connection = mysql.createConnection(env);
             connection.connect();
@@ -78,8 +80,6 @@ class context {
         }
     }
 
-
-
     __clearErrorHandler(){
         this._isModelValid = {
             isValid: true,
@@ -121,22 +121,26 @@ class context {
     }
 
     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;
+        this.isSQLite = 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}`;
+        var dbDirectory = options.completeConnection.substr(0, options.completeConnection.lastIndexOf("\/"));
+        if (!fs.existsSync(dbDirectory)){
+            fs.mkdirSync(dbDirectory);
+        }
+        this.db = this.__SQLiteInit(options,  "better-sqlite3");
+        this._SQLEngine.setDB(this.db, "better-sqlite3");
+        return this;
     }
 
     validateSQLiteOptions(options){
@@ -175,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");
             }
         }
         
@@ -227,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.33",
+  "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()
-*/