masterrecord 0.1.3 → 0.2.0

package/context.js

@@ -1,4 +1,4 @@
-// Version 0.0.8
+// Version 0.0.15
 
 var modelBuilder  = require('./Entity/entityModelBuilder');
 var query = require('masterrecord/QueryLanguage/queryMethods');
@@ -9,6 +9,7 @@ var insertManager = require('./insertManager');
 var deleteManager = require('./deleteManager');
 var globSearch = require("glob");
 var fs = require('fs');
+var path = require('path');
 const appRoot = require('app-root-path');
 const MySQLClient = require('masterrecord/mySQLSyncConnect');
 
@@ -54,6 +55,7 @@ class context {
         }
         catch (e) {
             console.log("error SQL", e);
+            throw new Error(String(e))
         }
     }
 
@@ -90,74 +92,187 @@ class context {
     };
 
     __findSettings(root, rootFolderLocation, envType){
-
         if(envType === undefined){
             envType = "development";
         }
-        var rootFolder = `${root}/${rootFolderLocation}`;
-        var search = `${rootFolder}/**/*env.${envType}.json`;
-        var files = globSearch.sync(search, rootFolder);
-        var file = files[0];
-        if(file === undefined){
-            root = tools.removeBackwardSlashSection(root, 1, "/");
-            rootFolder = `${root}/${rootFolderLocation}`;
-            var search = `${rootFolder}/**/*env.${envType}.json`;
-            var files = globSearch.sync(search,rootFolder);
-            file = files[0];
-            if(file === undefined){
-                root = tools.removeBackwardSlashSection(root, 1, "/");
-                rootFolder = `${root}/${rootFolderLocation}`;
-                var search = `${rootFolder}/**/*env.${envType}.json`;
-                var files = globSearch.sync(search,rootFolder);
-                file = files[0];
-                if(file === undefined){
-                    console.log(`could not find file - ${rootFolder}/env.${envType}.json`);
-                    throw error(`could not find file - ${rootFolder}/env.${envType}.json`);
+        let currentRoot = root;
+        const maxHops = 12;
+        for(let i = 0; i < maxHops; i++){
+            const rootFolder = path.isAbsolute(rootFolderLocation) ? rootFolderLocation : `${currentRoot}/${rootFolderLocation}`;
+            // Support both env.development.json and development.json naming
+            const searchA = `${rootFolder}/**/*env.${envType}.json`;
+            const searchB = `${rootFolder}/**/*${envType}.json`;
+            let files = globSearch.sync(searchA, currentRoot);
+            if(!files || files.length === 0){
+                files = globSearch.sync(searchB, currentRoot);
+            }
+            const file = files && files[0];
+            if(file){
+                return { file: file, rootFolder: currentRoot };
+            }
+            const parent = tools.removeBackwardSlashSection(currentRoot, 1, "/");
+            if(parent === currentRoot || parent === ""){
+                break;
+            }
+            currentRoot = parent;
+        }
+        const msg = `could not find env file '${rootFolderLocation}/env.${envType}.json' starting at ${root}`;
+        console.log(msg);
+        throw new Error(msg);
+    }
+
+    // Auto-detect DB type (sqlite or mysql) using environment JSON
+    env(rootFolderLocation){
+        try{
+            // Determine environment: prefer explicit, then NODE_ENV, fallback 'development'
+            let envType = this.__environment || process.env.NODE_ENV || 'development';
+            const contextName = this.__name;
+
+            // Try multiple base roots for robustness
+            const candidateRoots = [ process.cwd(), appRoot.path, __dirname ];
+            let file;
+            for(let i = 0; i < candidateRoots.length; i++){
+                try{
+                    file = this.__findSettings(candidateRoots[i], rootFolderLocation, envType);
+                    if(file) break;
+                }catch(_){ /* try next */ }
+            }
+            // If still not found and an absolute path was provided, try directly
+            if(!file && path.isAbsolute(rootFolderLocation)){
+                const directFolder = rootFolderLocation;
+                const envFileA = path.join(directFolder, `env.${envType}.json`);
+                const envFileB = path.join(directFolder, `${envType}.json`);
+                const picked = fs.existsSync(envFileA) ? envFileA : (fs.existsSync(envFileB) ? envFileB : null);
+                if(picked){
+                    file = { file: picked, rootFolder: path.dirname(path.dirname(picked)) };
                 }
+            }
+            if(!file){
+                throw new Error(`Environment config not found for '${envType}' under '${rootFolderLocation}'.`);
+            }
 
+            const settings = require(file.file);
+            const options = settings[contextName];
+            if(options === undefined){
+                console.log("settings missing context name settings");
+                throw new Error("settings missing context name settings");
             }
-        
+
+            const type = String(options.type || '').toLowerCase();
+
+            if(type === 'sqlite' || type === 'better-sqlite3'){
+                this.isSQLite = true; this.isMySQL = false;
+                // Back-compat: treat leading '/' as project-root relative, not filesystem root
+                let dbPath = options.connection || '';
+                if(dbPath){
+                    if(dbPath.startsWith(path.sep) || !path.isAbsolute(dbPath)){
+                        dbPath = path.join(file.rootFolder, dbPath);
+                    }
+                }
+                const dbDir = path.dirname(dbPath);
+                if(!fs.existsSync(dbDir)){
+                    fs.mkdirSync(dbDir, { recursive: true });
+                }
+                const sqliteOptions = { ...options, completeConnection: dbPath };
+                this.db = this.__SQLiteInit(sqliteOptions, 'better-sqlite3');
+                this._SQLEngine.setDB(this.db, 'better-sqlite3');
+                return this;
+            }
+
+            if(type === 'mysql'){
+                this.isMySQL = true; this.isSQLite = false;
+                this.db = this.__mysqlInit(options, 'mysql2');
+                this._SQLEngine.setDB(this.db, 'mysql');
+                return this;
+            }
+
+            throw new Error(`Unsupported database type '${options.type}'. Expected 'sqlite' or 'mysql'.`);
+        }
+        catch(err){
+            console.log("error:", err);
+            throw new Error(String(err));
         }
-        
-        return {
-            file: file,
-            rootFolder : root
-        };
     }
 
     useSqlite(rootFolderLocation){
-        this.isSQLite = true;
-        var root =  process.cwd();
-        var envType = this.__environment;
-        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");
-        }
+        try{
+            this.isSQLite = true;
+            var root =  process.cwd();
+            var envType = this.__environment;
+            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 new 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.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;
+            this.db = this.__SQLiteInit(options,  "better-sqlite3");
+            this._SQLEngine.setDB(this.db, "better-sqlite3");
+            return this;
+        }
+        catch(err){
+            console.log("error:",err );
+            throw new Error(String(err));
+        }
     }
 
     validateSQLiteOptions(options){
-        if(options.hasOwnProperty('connect') === undefined){
-            console.log("connnect string settings is missing")
-            throw error("connection string settings is missing");
+        if(!options || typeof options !== 'object'){
+            throw new Error("settings object is missing or invalid");
         }
 
+        // Normalize type
+        let type = (options.type || '').toString().toLowerCase();
+        if(!type){
+            // Infer when not provided
+            if(typeof options.connection === 'string'){
+                type = 'sqlite';
+                options.type = 'sqlite';
+            }
+            else if(options.host || options.user || options.database){
+                type = 'mysql';
+                options.type = 'mysql';
+            }
+        }
+
+        if(type === 'sqlite' || type === 'better-sqlite3'){
+            // Required
+            if(!options.connection || typeof options.connection !== 'string' || options.connection.trim() === ''){
+                throw new Error("connection string settings is missing");
+            }
+            // Defaults
+            if(options.username === undefined){ options.username = ''; }
+            if(options.password === undefined){ options.password = ''; }
+            return; // valid
+        }
+
+        if(type === 'mysql'){
+            // Defaults
+            if(!options.host){ options.host = 'localhost'; }
+            if(options.port === undefined){ options.port = 3306; }
+            if(options.password === undefined){ options.password = ''; }
+            // Required
+            if(!options.user || options.user.toString().trim() === ''){
+                throw new Error("MySQL 'user' is required in settings");
+            }
+            if(!options.database || options.database.toString().trim() === ''){
+                throw new Error("MySQL 'database' is required in settings");
+            }
+            return; // valid
+        }
+
+        throw new Error(`Unsupported database type '${options.type}'. Expected 'sqlite' or 'mysql'.`);
     }
     
     useMySql(rootFolderLocation){
@@ -172,9 +287,10 @@ class context {
             
             if(options === undefined){
                 console.log("settings missing context name settings");
-                throw error("settings missing context name settings");
+                throw new Error("settings missing context name settings");
             }
 
+            this.validateSQLiteOptions(options);
             this.db = this.__mysqlInit(options, "mysql2");
             this._SQLEngine.setDB(this.db, "mysql");
             return this;
@@ -213,12 +329,18 @@ class context {
                                 break;
                                 case "modified":
                                     if(currentModel.__dirtyFields.length > 0){
-                                        var cleanCurrentModel = tools.removePrimarykeyandVirtual(currentModel, currentModel._entity);
+                                        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);
+                                        if(argu !== -1 ){
+                                            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("Nothing has been tracked, modified, created or added");
+                                        }
+                                        
                                     }
                                     else{
                                         console.log("Tracked entity modified with no values being changed");
@@ -251,9 +373,15 @@ class context {
                                         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);
+                                        if(argu !== -1 ){
+                                            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("Nothing has been tracked, modified, created or added");
+                                        }
+                                       
                                     }
                                     else{
                                         console.log("Tracked entity modified with no values being changed");
@@ -279,8 +407,11 @@ class context {
         
         catch(error){
             this.__clearErrorHandler();
-            //this._SQLEngine.errorTransaction();
+            
             console.log("error", error);
+            if(this.isSQLite){
+                this._SQLEngine.errorTransaction();
+            }
             this.__clearTracked();
             throw error;
         }
@@ -303,6 +434,9 @@ class context {
         var add = true;
         for (var mod in this.__trackedEntities) {
             var id = this.__trackedEntities[mod].__ID;
+            if(id === undefined){
+                id = Math.floor((Math.random() * 100000) + 1);
+            }
             if(id === model.__ID){
                 add = false;
             }

package/deleteManager.js

@@ -1,4 +1,4 @@
-// version 0.0.2
+// version 0.0.3
 var tools =  require('./Tools');
 class DeleteManager{
     constructor(sqlEngine, entities){
@@ -23,7 +23,7 @@ class DeleteManager{
             // loop though all entity properties
             for (const property of entityKeys) {
                 // cascade delete
-                if(currentModel.__entity[property].type === "hasOne" || currentModel.__entity[property].type === "hasMany"){
+                if(currentModel.__entity[property].type === "hasOne" || currentModel.__entity[property].type === "hasMany" || currentModel.__entity[property].type === "hasManyThrough"){
                     var curModel = currentModel[property];
                     if(curModel === null){
                      // check if state is nullable - if so and nothing comes back dont call cascadeDelete
@@ -46,7 +46,7 @@ class DeleteManager{
                 // loop though all entity properties
                 for (const property of entityKeys) {
                     // cascade delete
-                    if(currentModel[i].__entity[property].type === "hasOne" || currentModel[i].__entity[property].type === "hasMany"){
+                    if(currentModel[i].__entity[property].type === "hasOne" || currentModel[i].__entity[property].type === "hasMany" || currentModel[i].__entity[property].type === "hasManyThrough"){
                         $that.cascadeDelete( currentModel[i][property]);
                     }
                 }

package/insertManager.js

@@ -1,5 +1,5 @@
 
-// version 0.0.5
+// version  0.0.15
 var tools =  require('./Tools');
 var queryScript = require('masterrecord/QueryLanguage/queryScript');
 
@@ -18,36 +18,61 @@ class InsertManager {
 
     runQueries(currentModel){
         var $that = this;
-        var cleanCurrentModel = tools.removePrimarykeyandVirtual(currentModel, currentModel.__entity);
+        // Reset validation state for this operation to avoid stale errors
+        if(this._errorModel){
+            this._errorModel.isValid = true;
+            this._errorModel.errors = [];
+        }
+        var cleanCurrentModel = tools.clearAllProto(currentModel);
         this.validateEntity(cleanCurrentModel, currentModel, currentModel.__entity);
         if(this._errorModel.isValid){
             
                 var modelEntity = currentModel.__entity;
                 // TODO: if you try to add belongs to you must have a tag added first. if you dont throw error
                 currentModel = this.belongsToInsert(currentModel, modelEntity);
-                var SQL = this._SQLEngine.insert(currentModel);
+                var SQL = this._SQLEngine.insert(cleanCurrentModel);
                 var primaryKey = tools.getPrimaryKeyObject(currentModel.__entity);
-                // return all fields that have auto and dont have a value to the current model on insert
+                // use returned insert id directly; avoid redundant post-insert SELECT
                 if(currentModel.__entity[primaryKey].auto === true){
-                    var query = `select * from ${currentModel.__entity.__name} where ${primaryKey} = ${ SQL.id }`;
-                    var jj = this.__queryObject.raw(query);
-                    var getQueryModel = this._SQLEngine.get(jj, currentModel.__entity, currentModel.__context );
-                    currentModel[primaryKey] = getQueryModel[0][primaryKey];
+                    currentModel[primaryKey] = SQL.id;
                 }
 
+                const proto = Object.getPrototypeOf(currentModel);
+                const props = Object.getOwnPropertyNames(proto);
+                const cleanPropList = tools.returnEntityList(props, modelEntity);
                 const modelKeys = Object.keys(currentModel);
+                const mergedArray =  [...new Set(modelKeys.concat(cleanPropList))];
                 // loop through model properties
-                for (const property of modelKeys) {
+                for (const property of mergedArray) {
                     var propertyModel = currentModel[property];
                     var entityProperty = modelEntity[property] ? modelEntity[property] : {};
                     if(entityProperty.type === "hasOne"){
-                        // make sure property model is an object not a primary data type like number or string
-                        if(typeof(propertyModel) === "object"){
+                        // only insert child if user provided a concrete object with data
+                        if(propertyModel && typeof(propertyModel) === "object" ){
                             // check if model has its own entity
                             if(modelEntity){
-                                propertyModel.__entity = tools.getEntity(property, $that._allEntities);
-                                propertyModel[currentModel.__entity.__name] = SQL.id;
-                                $that.runQueries(propertyModel);
+                                // check if property has a value because we dont want this to run on every insert if nothing was added
+                                // ensure it has some own props; otherwise skip
+                                const hasOwn = Object.keys(propertyModel).length > 0;
+                                if(hasOwn){
+                                    propertyModel.__entity = tools.getEntity(property, $that._allEntities);
+                                    propertyModel[currentModel.__entity.__name] = SQL.id;
+                                    $that.runQueries(propertyModel);
+                                    // Hydrate child back as a tracked instance so subsequent property sets are tracked
+                                    try{
+                                        var childPk = tools.getPrimaryKeyObject(propertyModel.__entity);
+                                        var childId = propertyModel[childPk];
+                                        if(childId !== undefined){
+                                            var ctxSetName = tools.capitalizeFirstLetter(property);
+                                            if(currentModel.__context && currentModel.__context[ctxSetName]){
+                                                var trackedChild = currentModel.__context[ctxSetName].where(`r => r.${childPk} == $$`, childId).single();
+                                                if(trackedChild){
+                                                    currentModel[property] = trackedChild;
+                                                }
+                                            }
+                                        }
+                                    }catch(_){ /* ignore tracking hydration errors */ }
+                                }
                             }
                             else{
                                 throw `Relationship "${entityProperty.name}" could not be found please check if object has correct spelling or if it has been added to the context class`
@@ -56,11 +81,58 @@ class InsertManager {
                     }
                     
                     if(entityProperty.type === "hasMany"){
-                        if(Array.isArray(propertyModel)){
+                        // skip when not provided; only enforce array type if user supplied a value
+                        if(propertyModel === undefined || propertyModel === null){
+                            continue;
+                        }
+                        if(tools.checkIfArrayLike(propertyModel)){
                             const propertyKeys = Object.keys(propertyModel);
                             for (const propertykey of propertyKeys) {
                                 if(propertyModel[propertykey]){
-                                    propertyModel[propertykey].__entity = tools.getEntity(property, $that._allEntities);
+                                    let targetName = entityProperty.foreignTable || property;
+                                    let resolved = tools.getEntity(targetName, $that._allEntities) 
+                                                    || tools.getEntity(tools.capitalize(targetName), $that._allEntities)
+                                                    || tools.getEntity(property, $that._allEntities);
+                                    if(!resolved){
+                                        throw `Relationship entity for '${property}' could not be resolved. Expected '${targetName}'.`;
+                                    }
+                                    // Coerce primitive into object with primary key if user passed an id
+                                    if(typeof propertyModel[propertykey] !== "object" || propertyModel[propertykey] === null){
+                                        const childPrimaryKey = tools.getPrimaryKeyObject(resolved);
+                                        const primitiveValue = propertyModel[propertykey];
+                                        propertyModel[propertykey] = {};
+                                        propertyModel[propertykey][childPrimaryKey] = primitiveValue;
+                                    }
+                                    propertyModel[propertykey].__entity = resolved;
+                                    propertyModel[propertykey][currentModel.__entity.__name] = SQL.id;
+                                    $that.runQueries(propertyModel[propertykey]);
+                                }
+                            }
+                        }
+                        else{
+                            throw `Relationship "${entityProperty.name}" must be an array`;
+                        }
+                    }
+
+                    if(entityProperty.type === "hasManyThrough"){
+                        if(tools.checkIfArrayLike(propertyModel)){
+                            const propertyKeys = Object.keys(propertyModel);
+                            for (const propertykey of propertyKeys) {
+                                if(propertyModel[propertykey]){
+                                    let targetName = entityProperty.foreignTable || property;
+                                    let resolved = tools.getEntity(targetName, $that._allEntities) 
+                                                    || tools.getEntity(tools.capitalize(targetName), $that._allEntities)
+                                                    || tools.getEntity(property, $that._allEntities);
+                                    if(!resolved){
+                                        throw `Relationship entity for '${property}' could not be resolved. Expected '${targetName}'.`;
+                                    }
+                                    if(typeof propertyModel[propertykey] !== "object" || propertyModel[propertykey] === null){
+                                        const childPrimaryKey = tools.getPrimaryKeyObject(resolved);
+                                        const primitiveValue = propertyModel[propertykey];
+                                        propertyModel[propertykey] = {};
+                                        propertyModel[propertykey][childPrimaryKey] = primitiveValue;
+                                    }
+                                    propertyModel[propertykey].__entity = resolved;
                                     propertyModel[propertykey][currentModel.__entity.__name] = SQL.id;
                                     $that.runQueries(propertyModel[propertykey]);
                                 }
@@ -74,11 +146,15 @@ class InsertManager {
                 }
         }
         else{
-            var name = currentModel.__entity.__name;
-            console.log(`entity ${name} not valid`);
+            var messages = this._errorModel.errors;
+            const combinedError = messages.join('; and ');
+            throw combinedError;
+
         }
     }
 
+    
+
     // will insert belongs to row first and return the id so that next call can be make correctly
     belongsToInsert(currentModel, modelEntity){
         var $that = this;
@@ -89,7 +165,7 @@ class InsertManager {
                 // 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);
+                    var propertyCleanCurrentModel = tools.clearAllProto(newPropertyModel);
                     this.validateEntity(propertyCleanCurrentModel, newPropertyModel, newPropertyModel.__entity);
                     var propertySQL = this._SQLEngine.insert(newPropertyModel);
                     currentModel[foreignKey] = propertySQL.id; 
@@ -102,35 +178,62 @@ class InsertManager {
             // update the currentModel.
         return currentModel;
     }
-    // validate entity for nullable fields
+
+    // validate entity for nullable fields and if the entity has any values at all
     validateEntity(currentModel, currentRealModel, entityModel){
         for(var entity in entityModel) {
             var currentEntity = entityModel[entity];
             if (entityModel.hasOwnProperty(entity)) {
                 // check if there is a default value
                 if(currentEntity.default){
-                    if(!currentRealModel[entity]){
+                    if(currentRealModel[entity] === undefined || currentRealModel[entity] === null){
                         // if its empty add the default value
                         currentRealModel[entity] = currentEntity.default;
                     }
                 }
             
-                // SKIP belongs too
+                // SKIP belongs too -----   // call sets for correct data for DB
                 if(currentEntity.type !== "belongsTo" && currentEntity.type !== "hasMany"){
                     if(currentEntity.relationshipType !== "belongsTo"){
+                        // Auto-populate common timestamp fields if required and missing
+                        if((entity === 'created_at' || entity === 'updated_at') && (currentRealModel[entity] === undefined || currentRealModel[entity] === null)){
+                            var nowVal = Date.now().toString();
+                            currentRealModel[entity] = nowVal;
+                            currentModel[entity] = nowVal;
+                        }
                         // 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.set === undefined){
-                                if(currentModel[entity] === undefined || currentModel[entity] === null || currentModel[entity] === "" ){
+                                const realVal = currentRealModel[entity];
+                                const cleanVal = currentModel[entity];
+                                let hasValue = (realVal !== undefined && realVal !== null) || (cleanVal !== undefined && cleanVal !== null);
+                                // For strings, empty string should be considered invalid for notNullable
+                                const candidate = (realVal !== undefined && realVal !== null) ? realVal : cleanVal;
+                                if(typeof candidate === 'string' && candidate.trim() === ''){
+                                    hasValue = false;
+                                }
+                                // Fallback: check backing field on tracked model if both reads were undefined/null
+                                if(!hasValue && currentRealModel && currentRealModel.__proto__){
+                                    const backing = currentRealModel.__proto__["_" + entity];
+                                    hasValue = (backing !== undefined && backing !== null);
+                                    if(hasValue){
+                                        // normalize into both models so downstream sees it
+                                        currentRealModel[entity] = backing;
+                                        currentModel[entity] = backing;
+                                    }
+                                }
+                                if(!hasValue){
                                     this._errorModel.isValid = false;
                                     var errorMessage = `Entity ${currentModel.__entity.__name} column ${entity} is a required Field`;
                                     this._errorModel.errors.push(errorMessage);
-                                    throw errorMessage;
+                                    //throw errorMessage;
                                 }
                             }
                             else{
-                                currentRealModel[entity] = currentEntity.set(currentModel[entity]);
+                                var realData = currentEntity.set(currentModel[entity]);
+                                currentRealModel[entity] = realData;
+                                currentModel[entity] = realData;
                             }
                         }
                     }