masterrecord 0.1.4 → 0.2.1

package/SQLLiteEngine.js

@@ -1,4 +1,4 @@
-// Version 0.0.13
+// Version 0.0.23
 var tools =  require('masterrecord/Tools');
 
 class SQLLiteEngine {
@@ -55,6 +55,23 @@ class SQLLiteEngine {
         }
     }
 
+    // Introspection helpers
+    tableExists(tableName){
+        try{
+            const sql = `SELECT name FROM sqlite_master WHERE type='table' AND name='${tableName}'`;
+            const row = this.db.prepare(sql).get();
+            return !!row;
+        }catch(_){ return false; }
+    }
+
+    getTableInfo(tableName){
+        try{
+            const sql = `PRAGMA table_info(${tableName})`;
+            const rows = this.db.prepare(sql).all();
+            return rows || [];
+        }catch(_){ return []; }
+    }
+
     getCount(queryObject, entity, context){
         var query = queryObject.script;
         var queryString = {};
@@ -256,54 +273,74 @@ class SQLLiteEngine {
     buildWhere(query, mainQuery){
         var whereEntity = query.where;
 
-        var strQuery = "";
         var $that = this;
-        if(whereEntity){
-            var entity = this.getEntity(query.parentName, query.entityMap);
+        if(!whereEntity){
+            return "";
+        }
 
-            var item = whereEntity[query.parentName].query;
-            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);
+        var entityAlias = this.getEntity(query.parentName, query.entityMap);
+        var item = whereEntity[query.parentName].query;
+        var exprs = item.expressions || [];
+
+        function exprToSql(expr){
+            var field = expr.field.toLowerCase();
+            var ent = entityAlias;
+            if(mainQuery[field]){
+                if(mainQuery[field].isNavigational){
+                    ent = $that.getEntity(field, query.entityMap);
+                    // field alias fallback kept as original logic; if item.fields exists, use second
+                    if(item.fields && item.fields[1]){
                         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"
-                    }
+            }
+            let func = expr.func;
+            let arg = expr.arg;
+            if((!func && typeof arg === 'undefined')){
+                return null;
+            }
+            // Removed fallback that coerced 'exists' with an argument to '='
+            // Bare field or !field: interpret as IS [NOT] NULL for SQLite
+            if(func === 'exists' && typeof arg === 'undefined'){
+                const isNull = expr.negate === true; // '!field' -> IS NULL
+                return `${ent}.${field}  is ${isNull ? '' : 'not '}null`;
+            }
+            if(arg === "null"){
+                if(func === "=") func = "is";
+                if(func === "!=") func = "is not";
+                return `${ent}.${field}  ${func} ${arg}`;
+            }
+            if(func === "IN"){
+                return `${ent}.${field}  ${func} ${arg}`;
+            }
+            return `${ent}.${field}  ${func} '${arg}'`;
+        }
+
+        const pieces = [];
+        for(let i = 0; i < exprs.length; i++){
+            const e = exprs[i];
+            if(e.group){
+                const gid = e.group;
+                const orParts = [];
+                while(i < exprs.length && exprs[i].group === gid){
+                    const sql = exprToSql(exprs[i]);
+                    if(sql){ orParts.push(sql); }
+                    i++;
                 }
-                if(strQuery === ""){
-                    if(item.expressions[exp].arg === "null"){
-                        strQuery = `WHERE ${entity}.${field}  ${item.expressions[exp].func} ${item.expressions[exp].arg}`;
-                    }else{
-                        if(item.expressions[exp].func === "IN"){
-                            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{
-                    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}'`;
-                    }
-                    
+                i--; // step back one since for-loop will increment
+                if(orParts.length > 0){
+                    pieces.push(`(${orParts.join(" or ")})`);
                 }
+            }else{
+                const sql = exprToSql(e);
+                if(sql){ pieces.push(sql); }
             }
+        }
 
-            
-                
+        if(pieces.length === 0){
+            return "";
         }
-        return strQuery;
+        return `WHERE ${pieces.join(" and ")}`;
     }
 
     buildInclude( query, entity, context){
@@ -464,6 +501,14 @@ class SQLLiteEngine {
                 }
             }
         }
+    // Ensure primary key is always included in SELECT list
+    try{
+        const pk = this.getPrimarykey(entity);
+        if(pk){
+            const hasPk = entitiesList.indexOf(pk) !== -1 || entitiesList.indexOf(`[${pk}]`) !== -1 || entitiesList.indexOf(`'${pk}'`) !== -1;
+            if(!hasPk){ entitiesList.unshift(pk); }
+        }
+    }catch(_){ /* ignore */ }
     return entitiesList
 }
     chechUnsupportedWords(word){
@@ -495,15 +540,47 @@ class SQLLiteEngine {
 
         for (var column in dirtyFields) {
 
+			// Validate non-nullable constraints on updates
+			var fieldName = dirtyFields[column];
+			var entityDef = model.__entity[fieldName];
+			if(entityDef && entityDef.nullable === false && entityDef.primary !== true){
+				// Determine the value that will actually be persisted for this field
+				var persistedValue;
+				switch(entityDef.type){
+					case "integer":
+						persistedValue = model["_" + fieldName];
+					break;
+					case "belongsTo":
+						persistedValue = model["_" + fieldName] !== undefined ? model["_" + fieldName] : model[fieldName];
+					break;
+					default:
+						persistedValue = model[fieldName];
+				}
+				var isEmptyString = (typeof persistedValue === 'string') && (persistedValue.trim() === '');
+				if(persistedValue === undefined || persistedValue === null || isEmptyString){
+					throw `Entity ${model.__entity.__name} column ${fieldName} is a required Field`;
+				}
+			}
+
+            var type = model.__entity[dirtyFields[column]].type;
+
+            if(model.__entity[dirtyFields[column]].relationshipType === "belongsTo"){
+                type = "belongsTo";
+            }
             // TODO Boolean value is a string with a letter
-            switch(model.__entity[dirtyFields[column]].type){
+            switch(type){
+                case "belongsTo" :
+                    const foreignKey = model.__entity[dirtyFields[column]].foreignKey;
+                    argument = `${foreignKey} = ${model[dirtyFields[column]]},`;
+                break;
                  case "integer" :
-                    //model.__entity[dirtyFields[column]].skipGetFunction = true;
-                    argument = argument === null ? `[${dirtyFields[column]}] = ${model[dirtyFields[column]]},` : `${argument} [${dirtyFields[column]}] = ${model[dirtyFields[column]]},`;
+                     //model.__entity[dirtyFields[column]].skipGetFunction = true;
+                    var columneValue = model[`_${dirtyFields[column]}`];
+                    argument = argument === null ? `[${dirtyFields[column]}] = ${model[dirtyFields[column]]},` : `${argument} [${dirtyFields[column]}] = ${columneValue},`;
                     //model.__entity[dirtyFields[column]].skipGetFunction = false;
                 break;
                 case "string" :
-                    argument = argument === null ? `[${dirtyFields[column]}] = '${$that._santizeSingleQuotes(model[dirtyFields[column]])}',` : `${argument} [${dirtyFields[column]}] = '${$that._santizeSingleQuotes(model[dirtyFields[column]])}',`;
+                    argument = argument === null ? `[${dirtyFields[column]}] = '${$that._santizeSingleQuotes(model[dirtyFields[column]], { entityName: model.__entity.__name, fieldName: dirtyFields[column] })}',` : `${argument} [${dirtyFields[column]}] = '${$that._santizeSingleQuotes(model[dirtyFields[column]], { entityName: model.__entity.__name, fieldName: dirtyFields[column] })}',`;
                 break;
                 case "boolean" :
                     var bool = "";
@@ -513,10 +590,10 @@ class SQLLiteEngine {
                     else{
                         bool = model[dirtyFields[column]];
                     }
-                    argument = argument === null ? `[${dirtyFields[column]}] = '${bool}',` : `${argument} [${dirtyFields[column]}] = ${bool},`;
+                    argument = argument === null ? `[${dirtyFields[column]}] = '${bool}',` : `${argument} [${dirtyFields[column]}] = '${bool}',`;
                 break;
                 case "time" :
-                    argument = argument === null ? `[${dirtyFields[column]}] = '${model[dirtyFields[column]]}',` : `${argument} [${dirtyFields[column]}] = ${model[dirtyFields[column]]},`;
+                    argument = argument === null ? `[${dirtyFields[column]}] = '${model[dirtyFields[column]]}',` : `${argument} [${dirtyFields[column]}] = '${model[dirtyFields[column]]}',`;
                 break;
                 case "belongsTo" :
                     var fore = `_${dirtyFields[column]}`;
@@ -529,7 +606,14 @@ class SQLLiteEngine {
                     argument = argument === null ? `[${dirtyFields[column]}] = '${model[dirtyFields[column]]}',` : `${argument} [${dirtyFields[column]}] = '${model[dirtyFields[column]]}',`;
             }
         }
-        return argument.replace(/,\s*$/, "");
+
+        if(argument){
+            return argument.replace(/,\s*$/, "");
+        }
+        else{
+            return -1;
+        }
+       
     }
 
     
@@ -554,20 +638,23 @@ class SQLLiteEngine {
                 // check if get function is avaliable if so use that
                 fieldColumn = fields[column];
 
-                if((fieldColumn !== undefined && fieldColumn !== null && fieldColumn !== "" ) && typeof(fieldColumn) !== "object"){
+                if((fieldColumn !== undefined && fieldColumn !== null ) && typeof(fieldColumn) !== "object"){
                     switch(modelEntity[column].type){
-                        case "belongsTo" :
-                            column = modelEntity[column].foreignKey === undefined ? column : modelEntity[column].foreignKey;
-                        break;
                         case "string" : 
-                            fieldColumn = `'${$that._santizeSingleQuotes(fields[column])}'`;
+                            fieldColumn = `'${$that._santizeSingleQuotes(fields[column], { entityName: modelEntity.__name, fieldName: column })}'`;
                         break;
                         case "time" : 
                             fieldColumn = fields[column];
                         break;
                     }
 
-                    columns = columns === null ? `'${column}',` : `${columns} '${column}',`;
+                    var relationship = modelEntity[column].relationshipType
+                    if(relationship === "belongsTo"){
+                        column = modelEntity[column].foreignKey
+                    }
+
+                    // Use bracket-quoted identifiers for SQLite column names
+                    columns = columns === null ? `[${column}],` : `${columns} [${column}],`;
                     values = values === null ? `${fieldColumn},` : `${values} ${fieldColumn},`;
 
                 }
@@ -579,7 +666,8 @@ class SQLLiteEngine {
                                 var primaryKey = tools.getPrimaryKeyObject(fieldObject.__entity);
                                 fieldColumn = fieldObject[primaryKey];
                                 column = modelEntity[column].foreignKey;
-                                columns = columns === null ? `'${column}',` : `${columns} '${column}',`;
+                                // Use bracket-quoted identifiers for SQLite column names
+                                columns = columns === null ? `[${column}],` : `${columns} [${column}],`;
                                 values = values === null ? `${fieldColumn},` : `${values} ${fieldColumn},`;
                             }else{
                                 console.log("Cannot find belings to relationship")
@@ -595,15 +683,24 @@ class SQLLiteEngine {
 
     }
 
-    // will add double single quotes to allow sting to be saved.
-    _santizeSingleQuotes(string){
-        if (typeof string === 'string' || string instanceof String){
-            return string.replace(/'/g, "''");
+    // will add double single quotes to allow string to be saved.
+    _santizeSingleQuotes(value, context){
+        if (typeof value === 'string' || value instanceof String){
+            return value.replace(/'/g, "''");
+        }
+        else{
+            var details = context || {};
+            var entityName = details.entityName || 'UnknownEntity';
+            var fieldName = details.fieldName || 'UnknownField';
+            var valueType = (value === null) ? 'null' : (value === undefined ? 'undefined' : typeof value);
+            var preview;
+            try{ preview = (value === null || value === undefined) ? String(value) : JSON.stringify(value); }
+            catch(_){ preview = '[unserializable]'; }
+            if(preview && preview.length > 120){ preview = preview.substring(0, 120) + '…'; }
+            var message = `Field is not a string: entity=${entityName}, field=${fieldName}, type=${valueType}, value=${preview}`;
+            console.error(message);
+            throw new Error(message);
         }
-    else{
-        console.log("warning - Field being passed is not a string");
-        throw "warning - Field being passed is not a string";
-    }
     }
 
     // converts any object into SQL parameter select string

package/Tools.js

@@ -1,6 +1,36 @@
-// Version 0.0.3
+// Version 0.0.5
 class Tools{
 
+    static checkIfArrayLike(obj) {
+        if (Array.isArray(obj)) {
+          return true;
+        }
+      
+        if (
+          obj &&
+          typeof obj === 'object' &&
+          Object.keys(obj).some(k => !isNaN(k)) &&
+          '0' in obj
+        ) {
+          return true;
+        }
+      
+        return -1;
+    }
+
+    static returnEntityList(list, entityList ){
+        var newList = [];
+        for(var max = 0; max < list.length; max++ ){
+            var ent = entityList[list[max]];
+            if(ent){
+                if(ent.relationshipType === "hasMany" || ent.relationshipType === "hasOne"){
+                    newList.push(ent.name);
+                } 
+            }
+        }
+        return newList;
+    }
+
     static findEntity(name, entityList){
         return entityList[name];
     }
@@ -15,25 +45,6 @@ class Tools{
         return stringArray.join(type);
     }
 
-    static removePrimarykeyandVirtual(currentModel, modelEntity){
-        var newCurrentModel = Object.create(currentModel);
-
-        for(var entity in modelEntity) {
-            var currentEntity = modelEntity[entity];
-            if (modelEntity.hasOwnProperty(entity)) {
-                if(currentEntity.primary === true){
-                    delete newCurrentModel[`_${entity}`];
-                }
-            }
-            if(currentEntity.virtual === true){
-                // skip it from the insert
-                delete newCurrentModel[`_${entity}`];
-            }
-
-        }
-        return newCurrentModel;
-    }
-
     static getPrimaryKeyObject(model){
         for (var key in model) {
             if (model.hasOwnProperty(key)) {
@@ -73,20 +84,54 @@ class Tools{
     }
 
     static clearAllProto(proto){
+       
+        var newproto = {}
         if(proto.__proto__ ){
-            proto.__proto__ = null;
-            for (var key in proto) {
-                if(!key.startsWith("_")){
-                    var typeObj = typeof(proto[key]);
-                    if(typeObj === "object"){
-                        this.clearAllProto(proto[key]);
-                    }
-                }else{
-                    throw "Cannot add relationship entity model only basic models"
+            // Include non-enumerable own properties so we don't lose values defined via getters
+            const keys = Object.getOwnPropertyNames(proto);
+            for (const key of keys) {
+                if(!key.startsWith("_") && !key.startsWith("__")){
+                    try{
+                        const value = proto[key];
+                        if(typeof value === "object" && value !== null){
+                            // Recursively clone nested objects without altering the source
+                            newproto[key] = this.clearAllProto(value);
+                        } else {
+                            newproto[key] = value;
+                        }
+                    }catch(_){ /* ignore getter errors */ }
                 }
             }
         }
 
+         newproto["__name"] = proto["__name"];
+         newproto["__state"] = proto["__state"];
+         newproto["__entity"] = proto["__entity"];
+         newproto["__context"] = proto["__context"];
+         newproto["__dirtyFields"] = proto["__dirtyFields"];
+         
+         newproto.__proto__ = null;
+        return newproto;
+
+    }
+
+    static removePrimarykeyandVirtual(currentModel, modelEntity){
+        var newCurrentModel = Object.create(currentModel);
+
+        for(var entity in modelEntity) {
+            var currentEntity = modelEntity[entity];
+            if (modelEntity.hasOwnProperty(entity)) {
+                if(currentEntity.primary === true){
+                    delete newCurrentModel[`_${entity}`];
+                }
+            }
+            if(currentEntity.virtual === true){
+                // skip it from the insert
+                delete newCurrentModel[`_${entity}`];
+            }
+
+        }
+        return newCurrentModel;
     }
 
     static getEntity(name, modelEntity){