masterrecord 0.1.4 → 0.2.1

package/mySQLEngine.js

@@ -1,4 +1,5 @@
-// version : 0.0.1
+// version : 0.0.9
+
 var tools =  require('masterrecord/Tools');
 var util = require('util');
 
@@ -97,6 +98,25 @@ class SQLLiteEngine {
         }
     }
 
+    // Introspection helpers
+    tableExists(tableName){
+        try{
+            const sql = `SELECT TABLE_NAME FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_SCHEMA = DATABASE() AND TABLE_NAME = '${tableName}'`;
+            this.db.connect(this.db);
+            const res = this.db.query(sql);
+            return Array.isArray(res) ? res.length > 0 : !!res?.length;
+        }catch(_){ return false; }
+    }
+
+    getTableInfo(tableName){
+        try{
+            const sql = `SELECT COLUMN_NAME as name, COLUMN_DEFAULT as dflt_value, IS_NULLABLE as is_nullable, DATA_TYPE as data_type FROM INFORMATION_SCHEMA.COLUMNS WHERE TABLE_SCHEMA = DATABASE() AND TABLE_NAME = '${tableName}'`;
+            this.db.connect(this.db);
+            const res = this.db.query(sql);
+            return res || [];
+        }catch(_){ return []; }
+    }
+
 
     buildQuery(query, entity, context){
 
@@ -122,32 +142,78 @@ class SQLLiteEngine {
     }
 
     buildWhere(query, mainQuery){
-        var whereEntity = query.where;
-        var strQuery = "";
-        var $that = this;
-        if(whereEntity){
-            var entity = this.getEntity(query.parentName, query.entityMap);
-            for (let part in whereEntity[query.parentName]) {
-                    var item = whereEntity[query.parentName][part];
-                    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(strQuery === ""){
-                            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}'`;
-                        }
-                    }
-                }
-        }
-        return strQuery;
-    }
+		var whereEntity = query.where;
+		var $that = this;
+		if(!whereEntity){
+			return "";
+		}
+
+		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);
+					if(item.fields && item.fields[1]){
+						field = item.fields[1];
+					}
+				}
+			}
+			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
+			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}`;
+			}
+            var safeArg = (typeof arg === 'string' || arg instanceof String)
+                ? $that._santizeSingleQuotes(arg, { entityName: ent, fieldName: field })
+                : String(arg);
+            return `${ent}.${field}  ${func} '${safeArg}'`;
+		}
+
+		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++;
+				}
+				i--; // compensate for loop 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 `WHERE ${pieces.join(" and ")}`;
+	}
 
     buildInclude( query, entity, context){
         var includeQuery =  "";
@@ -307,6 +373,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;
+                if(!hasPk){ entitiesList.unshift(pk); }
+            }
+        }catch(_){ /* ignore */ }
         return entitiesList
     }
 
@@ -338,6 +412,27 @@ class SQLLiteEngine {
         var dirtyFields = model.__dirtyFields;
         
         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`;
+                }
+            }
             // TODO Boolean value is a string with a letter
             var type = model.__entity[dirtyFields[column]].type;
             
@@ -347,14 +442,19 @@ class SQLLiteEngine {
 
             switch(type){
                 case "belongsTo" :
-                    var foreignKey = model.__entity[dirtyFields[column]].foreignKey;
+                    const foreignKey = model.__entity[dirtyFields[column]].foreignKey;
                     argument = `${foreignKey} = ${model[dirtyFields[column]]},`;
                 break;
                 case "integer" :
-                    argument = argument === null ? `${dirtyFields[column]} = ${model[dirtyFields[column]]},` : `${argument} ${dirtyFields[column]} = ${model[dirtyFields[column]]},`;
+                    const columneValue = model[`_${dirtyFields[column]}`];
+                    argument = argument === null ? `[${dirtyFields[column]}] = ${model[dirtyFields[column]]},` : `${argument} [${dirtyFields[column]}] = ${columneValue},`;
                 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 "time" :
+                    // Always quote time values so empty strings remain valid ('')
+                    argument = argument === null ? `${dirtyFields[column]} = '${model[dirtyFields[column]]}',` : `${argument} ${dirtyFields[column]} = '${model[dirtyFields[column]]}',`;
                 break;
                 case "boolean" :
                     argument = argument === null ? `${dirtyFields[column]} = '${this.boolType(model[dirtyFields[column]])}',` : `${argument} ${dirtyFields[column]} = '${this.boolType(model[dirtyFields[column]])}',`;
@@ -363,7 +463,12 @@ 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;
+        }
     }
 
     boolType(type){
@@ -402,15 +507,14 @@ 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 "string" : 
-                            fieldColumn = `'${$that._santizeSingleQuotes(fields[column])}'`;
+                            fieldColumn = `'${$that._santizeSingleQuotes(fields[column], { entityName: modelEntity.__name, fieldName: column })}'`;
                         break;
                         case "time" : 
-                            fieldColumn = fields[column];
+                            // Quote time values to prevent blank values from producing malformed SQL
+                            fieldColumn = `'${fields[column]}'`;
                         break;
                     }
                     
@@ -420,7 +524,8 @@ class SQLLiteEngine {
                     }
 
 
-                    columns = columns === null ? `${column},` : `${columns} ${column},`;
+                    // Use backtick-quoted identifiers for MySQL column names
+                    columns = columns === null ? `\`${column}\`,` : `${columns} \`${column}\`,`;
                     values = values === null ? `${fieldColumn},` : `${values} ${fieldColumn},`;
 
                 }
@@ -431,13 +536,23 @@ class SQLLiteEngine {
 
     }
 
-    // will add double single quotes to allow sting to be saved.
-    _santizeSingleQuotes(string){
-
-        if(typeof string === "string"){
-            return string.replace(/'/g, "''");
-        }else{
-            return `${string}`;
+    // 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);
         }
     }
 

package/mySQLSyncConnect.js

@@ -1,5 +1,6 @@
-var MySql = require('sync-mysql2');
+// version : 0.0.1
 
+var MySql = require('sync-mysql2');
 
 class MySQLClient {
     constructor(config) {

package/package.json

@@ -1,14 +1,14 @@
 {
   "name": "masterrecord",
   "dependencies": {
-    "commander": "^13.1.0",
-    "glob" : "^11.0.1",
+    "commander": "^14.0.1",
+    "glob" : "^11.0.3",
     "deep-object-diff" : "^1.1.9",
-    "pg" : "^8.14.1",
-    "sync-mysql2" : "^1.0.5",
+    "pg" : "^8.16.3",
+    "sync-mysql2" : "^1.0.6",
     "app-root-path": "^3.1.0"
   },
-  "version": "0.1.4",
+  "version": "0.2.1",
   "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/readme.md

@@ -1 +1,3 @@
-local install of CLI package run code in terminal - "npm install -g ./" master
+local install of CLI package run code in terminal - "npm install -g ./" master
+
+For full instructions on running migrations and updating the server, see `MIGRATIONS.md`.