masterrecord 0.2.31 → 0.2.33

package/.claude/settings.local.json

@@ -0,0 +1,11 @@
+{
+  "permissions": {
+    "allow": [
+      "Read(//Users/alexanderrich/Documents/development/bookbaghq/bookbag-ce/components/models/app/models/**)",
+      "Read(//Users/alexanderrich/Documents/development/bookbaghq/bookbag-ce/components/models/app/controllers/api/**)",
+      "Read(//Users/alexanderrich/Documents/development/bookbaghq/bookbag-ce/config/environments/**)"
+    ],
+    "deny": [],
+    "ask": []
+  }
+}

package/Migrations/cli.js

@@ -280,53 +280,173 @@ program.option('-V', 'output the version');
     contextFileName = contextFileName.toLowerCase();
     var migration = new Migration();
       try{
+         console.log(`\n🔍 Searching for context snapshot '${contextFileName}_contextSnapShot.json'...`);
          // find context snapshot (cwd-based glob)
          var files = globSearch.sync(`**/*${contextFileName}_contextSnapShot.json`, { cwd: executedLocation, dot: true, windowsPathsNoEscape: true, nocase: true });
          var file = files && files[0] ? path.resolve(executedLocation, files[0]) : null;
-         if(file){
-          var contextSnapshot = require(file);
-          const snapDir = path.dirname(file);
-          const contextAbs = path.resolve(snapDir, contextSnapshot.contextLocation || '');
-          const migBase = path.resolve(snapDir, contextSnapshot.migrationFolder || '.');
-          var migrationFiles = globSearch.sync(`**/*_migration.js`, { cwd: migBase, dot: true, windowsPathsNoEscape: true });
-          migrationFiles = (migrationFiles || []).map(f => path.resolve(migBase, f));
-          if( migrationFiles && migrationFiles.length){
-            // sort by timestamp prefix or file mtime as fallback
-            var mFiles = migrationFiles.slice().sort(function(a, b){
-              return __getMigrationTimestamp(a) - __getMigrationTimestamp(b);
-            });
-            var mFile = mFiles[mFiles.length -1];
-
-            var migrationProjectFile = require(mFile);
-            var ContextCtor = require(contextAbs);
-            var contextInstance = new ContextCtor();
-            var newMigrationProjectInstance = new migrationProjectFile(ContextCtor);
 
-            var cleanEntities = migration.cleanEntities(contextInstance.__entities);
-            var tableObj = migration.buildUpObject(contextSnapshot.schema, cleanEntities);
-             newMigrationProjectInstance.up(tableObj);
-            
-             var snap = {
-               file : contextAbs,
-               executedLocation : executedLocation,
-               context : contextInstance,
-               contextEntities : cleanEntities,
-               contextFileName: contextFileName
-             }
- 
-             migration.createSnapShot(snap);
-             console.log("✓ Database updated successfully");
-          }
-          else{
-           console.log("Error - Cannot read or find migration file");
-          }
+         if(!file){
+           console.error(`\n❌ Error - Cannot find Context snapshot file`);
+           console.error(`\nSearched for: ${contextFileName}_contextSnapShot.json`);
+           console.error(`Searched in: ${executedLocation}`);
+           console.error(`\n💡 Solution: Run 'masterrecord enable-migrations ${contextFileName}' first`);
+           return;
+         }
 
+         console.log(`✓ Found snapshot: ${file}`);
+
+         var contextSnapshot;
+         try{
+           contextSnapshot = require(file);
+         }catch(err){
+           console.error(`\n❌ Error - Cannot load context snapshot`);
+           console.error(`\nFile: ${file}`);
+           console.error(`Details: ${err.message}`);
+           return;
          }
-         else{
-           console.log("Error - Cannot read or find Context file");
-          }
+
+         const snapDir = path.dirname(file);
+         const contextAbs = path.resolve(snapDir, contextSnapshot.contextLocation || '');
+         const migBase = path.resolve(snapDir, contextSnapshot.migrationFolder || '.');
+
+         console.log(`\n🔍 Searching for migration files in: ${migBase}`);
+         var migrationFiles = globSearch.sync(`**/*_migration.js`, { cwd: migBase, dot: true, windowsPathsNoEscape: true });
+         migrationFiles = (migrationFiles || []).map(f => path.resolve(migBase, f));
+
+         if(!(migrationFiles && migrationFiles.length)){
+           console.error(`\n❌ Error - No migration files found`);
+           console.error(`\nSearched in: ${migBase}`);
+           console.error(`\n💡 Solution: Run 'masterrecord add-migration Init ${contextFileName}' to create your first migration`);
+           return;
+         }
+
+         // sort by timestamp prefix or file mtime as fallback
+         var mFiles = migrationFiles.slice().sort(function(a, b){
+           return __getMigrationTimestamp(a) - __getMigrationTimestamp(b);
+         });
+         var mFile = mFiles[mFiles.length -1];
+         console.log(`✓ Found ${mFiles.length} migration file(s), using latest: ${path.basename(mFile)}`);
+
+         console.log(`\n🔍 Loading Context file from: ${contextAbs}`);
+         var migrationProjectFile;
+         var ContextCtor;
+         try{
+           migrationProjectFile = require(mFile);
+           ContextCtor = require(contextAbs);
+         }catch(err){
+           console.error(`\n❌ Error - Cannot load Context or migration file`);
+           console.error(`\nContext file: ${contextAbs}`);
+           console.error(`Migration file: ${mFile}`);
+           console.error(`\nDetails: ${err.message}`);
+           if(err.stack){
+             console.error(`\nStack trace:`);
+             console.error(err.stack);
+           }
+           return;
+         }
+
+         console.log(`✓ Context file loaded successfully`);
+         console.log(`\n🔍 Instantiating Context (this will create the database if it doesn't exist)...`);
+
+         var contextInstance;
+         try{
+           contextInstance = new ContextCtor();
+         }catch(err){
+           console.error(`\n❌ Error - Failed to instantiate Context`);
+           console.error(`\nContext file: ${contextAbs}`);
+           console.error(`\nThis usually happens when:`);
+           console.error(`  • Environment configuration file is missing`);
+           console.error(`  • Database connection settings are incorrect`);
+           console.error(`  • The 'master' environment variable is not set`);
+           console.error(`  • Required dependencies are not installed`);
+           console.error(`\nDetails: ${err.message}`);
+           if(err.stack){
+             console.error(`\nStack trace:`);
+             console.error(err.stack);
+           }
+           console.error(`\n💡 Check your environment config file (e.g., config/environments/env.development.json)`);
+           console.error(`💡 Make sure you're running: master=development masterrecord update-database ${contextFileName}`);
+           return;
+         }
+
+         console.log(`✓ Context instantiated successfully`);
+
+         // Log database connection details
+         if(contextInstance.isSQLite && contextInstance.db){
+           const dbPath = contextInstance.db.name || 'unknown';
+           console.log(`\n📊 Database Type: SQLite`);
+           console.log(`📁 Database Path: ${dbPath}`);
+
+           // Check if the database file exists
+           if(fs.existsSync(dbPath)){
+             const stats = fs.statSync(dbPath);
+             console.log(`✓ Database file exists (${(stats.size / 1024).toFixed(2)} KB)`);
+           }else{
+             console.log(`⚠️  Database file does not exist yet (will be created during migration)`);
+           }
+         }else if(contextInstance.isMySQL){
+           console.log(`\n📊 Database Type: MySQL`);
+         }
+
+         console.log(`\n🔍 Loading entities from context...`);
+         var cleanEntities = migration.cleanEntities(contextInstance.__entities);
+         console.log(`✓ Found ${cleanEntities.length} entity/entities`);
+
+         if(cleanEntities.length === 0){
+           console.error(`\n⚠️  Warning - No entities found in Context`);
+           console.error(`\nMake sure your Context file has dbset() calls to register entities`);
+           console.error(`Example:`);
+           console.error(`  this.dbset(User, 'User');`);
+           console.error(`  this.dbset(Post, 'Post');`);
+         }
+
+         console.log(`\n🚀 Running migration...`);
+         try{
+           var newMigrationProjectInstance = new migrationProjectFile(ContextCtor);
+           var tableObj = migration.buildUpObject(contextSnapshot.schema, cleanEntities);
+           newMigrationProjectInstance.up(tableObj);
+         }catch(err){
+           console.error(`\n❌ Error - Migration failed during execution`);
+           console.error(`\nMigration file: ${mFile}`);
+           console.error(`\nDetails: ${err.message}`);
+           if(err.stack){
+             console.error(`\nStack trace:`);
+             console.error(err.stack);
+           }
+           return;
+         }
+
+         console.log(`\n💾 Updating snapshot...`);
+         var snap = {
+           file : contextAbs,
+           executedLocation : executedLocation,
+           context : contextInstance,
+           contextEntities : cleanEntities,
+           contextFileName: contextFileName
+         }
+
+         migration.createSnapShot(snap);
+         console.log(`\n✅ Database updated successfully!`);
+
+         // Final verification for SQLite
+         if(contextInstance.isSQLite && contextInstance.db){
+           const dbPath = contextInstance.db.name || 'unknown';
+           if(fs.existsSync(dbPath)){
+             const stats = fs.statSync(dbPath);
+             console.log(`\n📁 Database file: ${dbPath}`);
+             console.log(`📊 Size: ${(stats.size / 1024).toFixed(2)} KB`);
+           }else{
+             console.error(`\n⚠️  Warning - Database file was not created at expected path: ${dbPath}`);
+           }
+         }
+
         }catch (e){
-          console.log("Error - Cannot read or find file ", e);
+          console.error(`\n❌ Unexpected error during update-database`);
+          console.error(`\nDetails: ${e.message}`);
+          if(e.stack){
+            console.error(`\nStack trace:`);
+            console.error(e.stack);
+          }
         }
   });
 

package/SQLLiteEngine.js

@@ -571,29 +571,64 @@ class SQLLiteEngine {
             switch(type){
                 case "belongsTo" :
                     const foreignKey = model.__entity[dirtyFields[column]].foreignKey;
-                    argument = `${foreignKey} = ${model[dirtyFields[column]]},`;
+                    let fkValue = model[dirtyFields[column]];
+                    // 🔥 NEW: Validate foreign key type
+                    try {
+                        fkValue = $that._validateAndCoerceFieldType(fkValue, model.__entity[dirtyFields[column]], model.__entity.__name, dirtyFields[column]);
+                    } catch(typeError) {
+                        throw new Error(`UPDATE failed: ${typeError.message}`);
+                    }
+                    argument = `${foreignKey} = ${fkValue},`;
                 break;
                  case "integer" :
                      //model.__entity[dirtyFields[column]].skipGetFunction = true;
                     var columneValue = model[`_${dirtyFields[column]}`];
-                    argument = argument === null ? `[${dirtyFields[column]}] = ${model[dirtyFields[column]]},` : `${argument} [${dirtyFields[column]}] = ${columneValue},`;
+                    var intValue = columneValue !== undefined ? columneValue : model[dirtyFields[column]];
+                    // 🔥 NEW: Validate integer type
+                    try {
+                        intValue = $that._validateAndCoerceFieldType(intValue, model.__entity[dirtyFields[column]], model.__entity.__name, dirtyFields[column]);
+                    } catch(typeError) {
+                        throw new Error(`UPDATE failed: ${typeError.message}`);
+                    }
+                    argument = argument === null ? `[${dirtyFields[column]}] = ${intValue},` : `${argument} [${dirtyFields[column]}] = ${intValue},`;
                     //model.__entity[dirtyFields[column]].skipGetFunction = false;
                 break;
                 case "string" :
-                    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] })}',`;
+                    var strValue = model[dirtyFields[column]];
+                    // 🔥 NEW: Validate string type
+                    try {
+                        strValue = $that._validateAndCoerceFieldType(strValue, model.__entity[dirtyFields[column]], model.__entity.__name, dirtyFields[column]);
+                    } catch(typeError) {
+                        throw new Error(`UPDATE failed: ${typeError.message}`);
+                    }
+                    argument = argument === null ? `[${dirtyFields[column]}] = '${$that._santizeSingleQuotes(strValue, { entityName: model.__entity.__name, fieldName: dirtyFields[column] })}',` : `${argument} [${dirtyFields[column]}] = '${$that._santizeSingleQuotes(strValue, { entityName: model.__entity.__name, fieldName: dirtyFields[column] })}',`;
                 break;
                 case "boolean" :
                     var bool = "";
+                    var boolValue = model[dirtyFields[column]];
+                    // 🔥 NEW: Validate boolean type
+                    try {
+                        boolValue = $that._validateAndCoerceFieldType(boolValue, model.__entity[dirtyFields[column]], model.__entity.__name, dirtyFields[column]);
+                    } catch(typeError) {
+                        throw new Error(`UPDATE failed: ${typeError.message}`);
+                    }
                     if(model.__entity[dirtyFields[column]].valueConversion){
-                        bool = tools.convertBooleanToNumber(model[dirtyFields[column]]);
+                        bool = tools.convertBooleanToNumber(boolValue);
                     }
                     else{
-                        bool = model[dirtyFields[column]];
+                        bool = boolValue;
                     }
                     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]]}',`;
+                    var timeValue = model[dirtyFields[column]];
+                    // 🔥 NEW: Validate time type
+                    try {
+                        timeValue = $that._validateAndCoerceFieldType(timeValue, model.__entity[dirtyFields[column]], model.__entity.__name, dirtyFields[column]);
+                    } catch(typeError) {
+                        throw new Error(`UPDATE failed: ${typeError.message}`);
+                    }
+                    argument = argument === null ? `[${dirtyFields[column]}] = '${timeValue}',` : `${argument} [${dirtyFields[column]}] = '${timeValue}',`;
                 break;
                 case "belongsTo" :
                     var fore = `_${dirtyFields[column]}`;
@@ -624,6 +659,98 @@ class SQLLiteEngine {
         return {tableName: tableName, primaryKey : primaryKey, value : value};
     }
 
+    /**
+     * Validate and coerce field value to match entity type definition
+     * Throws detailed error if type cannot be coerced
+     * @param {*} value - The field value to validate
+     * @param {object} entityDef - The entity definition for this field
+     * @param {string} entityName - Name of the entity (for error messages)
+     * @param {string} fieldName - Name of the field (for error messages)
+     * @returns {*} - The validated/coerced value
+     */
+    _validateAndCoerceFieldType(value, entityDef, entityName, fieldName){
+        if(value === undefined || value === null){
+            return value; // Let nullable validation handle this
+        }
+
+        const expectedType = entityDef.type;
+        const actualType = typeof value;
+
+        switch(expectedType){
+            case "integer":
+                // Coerce to integer if possible
+                if(actualType === 'number'){
+                    if(!Number.isInteger(value)){
+                        console.warn(`⚠️  Field ${entityName}.${fieldName}: Expected integer but got float ${value}, rounding to ${Math.round(value)}`);
+                        return Math.round(value);
+                    }
+                    return value;
+                }
+                if(actualType === 'string'){
+                    const parsed = parseInt(value, 10);
+                    if(isNaN(parsed)){
+                        throw new Error(`Type mismatch for ${entityName}.${fieldName}: Expected integer, got string "${value}" which cannot be converted to a number`);
+                    }
+                    console.warn(`⚠️  Field ${entityName}.${fieldName}: Auto-converting string "${value}" to integer ${parsed}`);
+                    return parsed;
+                }
+                if(actualType === 'boolean'){
+                    console.warn(`⚠️  Field ${entityName}.${fieldName}: Auto-converting boolean ${value} to integer ${value ? 1 : 0}`);
+                    return value ? 1 : 0;
+                }
+                throw new Error(`Type mismatch for ${entityName}.${fieldName}: Expected integer, got ${actualType} with value ${JSON.stringify(value)}`);
+
+            case "string":
+                // Coerce to string
+                if(actualType === 'string'){
+                    return value;
+                }
+                // Allow auto-conversion from primitives
+                if(['number', 'boolean'].includes(actualType)){
+                    console.warn(`⚠️  Field ${entityName}.${fieldName}: Auto-converting ${actualType} ${value} to string "${String(value)}"`);
+                    return String(value);
+                }
+                throw new Error(`Type mismatch for ${entityName}.${fieldName}: Expected string, got ${actualType} with value ${JSON.stringify(value)}`);
+
+            case "boolean":
+                // Coerce to boolean
+                if(actualType === 'boolean'){
+                    return value;
+                }
+                if(actualType === 'number'){
+                    console.warn(`⚠️  Field ${entityName}.${fieldName}: Auto-converting number ${value} to boolean ${value !== 0}`);
+                    return value !== 0;
+                }
+                if(actualType === 'string'){
+                    const lower = value.toLowerCase().trim();
+                    if(['true', '1', 'yes'].includes(lower)){
+                        console.warn(`⚠️  Field ${entityName}.${fieldName}: Auto-converting string "${value}" to boolean true`);
+                        return true;
+                    }
+                    if(['false', '0', 'no', ''].includes(lower)){
+                        console.warn(`⚠️  Field ${entityName}.${fieldName}: Auto-converting string "${value}" to boolean false`);
+                        return false;
+                    }
+                    throw new Error(`Type mismatch for ${entityName}.${fieldName}: Expected boolean, got string "${value}" which cannot be converted`);
+                }
+                throw new Error(`Type mismatch for ${entityName}.${fieldName}: Expected boolean, got ${actualType} with value ${JSON.stringify(value)}`);
+
+            case "time":
+                // Time fields should be strings or timestamps
+                if(actualType === 'string' || actualType === 'number'){
+                    return value;
+                }
+                throw new Error(`Type mismatch for ${entityName}.${fieldName}: Expected time (string/number), got ${actualType} with value ${JSON.stringify(value)}`);
+
+            default:
+                // For unknown types, allow the value through but warn
+                if(actualType === 'object'){
+                    console.warn(`⚠️  Field ${entityName}.${fieldName}: Setting object value for type "${expectedType}". This may cause issues.`);
+                }
+                return value;
+        }
+    }
+
 
        // return columns and value strings
     _buildSQLInsertObject(fields, modelEntity){
@@ -639,12 +766,19 @@ class SQLLiteEngine {
                 fieldColumn = fields[column];
 
                 if((fieldColumn !== undefined && fieldColumn !== null ) && typeof(fieldColumn) !== "object"){
+                    // 🔥 NEW: Validate and coerce field type before processing
+                    try {
+                        fieldColumn = $that._validateAndCoerceFieldType(fieldColumn, modelEntity[column], modelEntity.__name, column);
+                    } catch(typeError) {
+                        throw new Error(`INSERT failed: ${typeError.message}`);
+                    }
+
                     switch(modelEntity[column].type){
-                        case "string" : 
-                            fieldColumn = `'${$that._santizeSingleQuotes(fields[column], { entityName: modelEntity.__name, fieldName: column })}'`;
+                        case "string" :
+                            fieldColumn = `'${$that._santizeSingleQuotes(fieldColumn, { entityName: modelEntity.__name, fieldName: column })}'`;
                         break;
-                        case "time" : 
-                            fieldColumn = fields[column];
+                        case "time" :
+                            fieldColumn = fieldColumn;
                         break;
                     }
 

package/mySQLEngine.js

@@ -443,21 +443,56 @@ class SQLLiteEngine {
             switch(type){
                 case "belongsTo" :
                     const foreignKey = model.__entity[dirtyFields[column]].foreignKey;
-                    argument = `${foreignKey} = ${model[dirtyFields[column]]},`;
+                    let fkValue = model[dirtyFields[column]];
+                    // 🔥 NEW: Validate foreign key type
+                    try {
+                        fkValue = $that._validateAndCoerceFieldType(fkValue, model.__entity[dirtyFields[column]], model.__entity.__name, dirtyFields[column]);
+                    } catch(typeError) {
+                        throw new Error(`UPDATE failed: ${typeError.message}`);
+                    }
+                    argument = `${foreignKey} = ${fkValue},`;
                 break;
                 case "integer" :
                     const columneValue = model[`_${dirtyFields[column]}`];
-                    argument = argument === null ? `[${dirtyFields[column]}] = ${model[dirtyFields[column]]},` : `${argument} [${dirtyFields[column]}] = ${columneValue},`;
+                    var intValue = columneValue !== undefined ? columneValue : model[dirtyFields[column]];
+                    // 🔥 NEW: Validate integer type
+                    try {
+                        intValue = $that._validateAndCoerceFieldType(intValue, model.__entity[dirtyFields[column]], model.__entity.__name, dirtyFields[column]);
+                    } catch(typeError) {
+                        throw new Error(`UPDATE failed: ${typeError.message}`);
+                    }
+                    argument = argument === null ? `[${dirtyFields[column]}] = ${intValue},` : `${argument} [${dirtyFields[column]}] = ${intValue},`;
                 break;
                 case "string" :
-                    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] })}',`;
+                    var strValue = model[dirtyFields[column]];
+                    // 🔥 NEW: Validate string type
+                    try {
+                        strValue = $that._validateAndCoerceFieldType(strValue, model.__entity[dirtyFields[column]], model.__entity.__name, dirtyFields[column]);
+                    } catch(typeError) {
+                        throw new Error(`UPDATE failed: ${typeError.message}`);
+                    }
+                    argument = argument === null ? `${dirtyFields[column]} = '${$that._santizeSingleQuotes(strValue, { entityName: model.__entity.__name, fieldName: dirtyFields[column] })}',` : `${argument} ${dirtyFields[column]} = '${$that._santizeSingleQuotes(strValue, { 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]]}',`;
+                    var timeValue = model[dirtyFields[column]];
+                    // 🔥 NEW: Validate time type
+                    try {
+                        timeValue = $that._validateAndCoerceFieldType(timeValue, model.__entity[dirtyFields[column]], model.__entity.__name, dirtyFields[column]);
+                    } catch(typeError) {
+                        throw new Error(`UPDATE failed: ${typeError.message}`);
+                    }
+                    argument = argument === null ? `${dirtyFields[column]} = '${timeValue}',` : `${argument} ${dirtyFields[column]} = '${timeValue}',`;
                 break;
                 case "boolean" :
-                    argument = argument === null ? `${dirtyFields[column]} = '${this.boolType(model[dirtyFields[column]])}',` : `${argument} ${dirtyFields[column]} = '${this.boolType(model[dirtyFields[column]])}',`;
+                    var boolValue = model[dirtyFields[column]];
+                    // 🔥 NEW: Validate boolean type
+                    try {
+                        boolValue = $that._validateAndCoerceFieldType(boolValue, model.__entity[dirtyFields[column]], model.__entity.__name, dirtyFields[column]);
+                    } catch(typeError) {
+                        throw new Error(`UPDATE failed: ${typeError.message}`);
+                    }
+                    argument = argument === null ? `${dirtyFields[column]} = '${this.boolType(boolValue)}',` : `${argument} ${dirtyFields[column]} = '${this.boolType(boolValue)}',`;
                 break;
                 default:
                     argument = argument === null ? `${dirtyFields[column]} = '${model[dirtyFields[column]]}',` : `${argument} ${dirtyFields[column]} = '${model[dirtyFields[column]]}',`;
@@ -493,6 +528,98 @@ class SQLLiteEngine {
         return {tableName: tableName, primaryKey : primaryKey, value : value};
     }
 
+    /**
+     * Validate and coerce field value to match entity type definition
+     * Throws detailed error if type cannot be coerced
+     * @param {*} value - The field value to validate
+     * @param {object} entityDef - The entity definition for this field
+     * @param {string} entityName - Name of the entity (for error messages)
+     * @param {string} fieldName - Name of the field (for error messages)
+     * @returns {*} - The validated/coerced value
+     */
+    _validateAndCoerceFieldType(value, entityDef, entityName, fieldName){
+        if(value === undefined || value === null){
+            return value; // Let nullable validation handle this
+        }
+
+        const expectedType = entityDef.type;
+        const actualType = typeof value;
+
+        switch(expectedType){
+            case "integer":
+                // Coerce to integer if possible
+                if(actualType === 'number'){
+                    if(!Number.isInteger(value)){
+                        console.warn(`⚠️  Field ${entityName}.${fieldName}: Expected integer but got float ${value}, rounding to ${Math.round(value)}`);
+                        return Math.round(value);
+                    }
+                    return value;
+                }
+                if(actualType === 'string'){
+                    const parsed = parseInt(value, 10);
+                    if(isNaN(parsed)){
+                        throw new Error(`Type mismatch for ${entityName}.${fieldName}: Expected integer, got string "${value}" which cannot be converted to a number`);
+                    }
+                    console.warn(`⚠️  Field ${entityName}.${fieldName}: Auto-converting string "${value}" to integer ${parsed}`);
+                    return parsed;
+                }
+                if(actualType === 'boolean'){
+                    console.warn(`⚠️  Field ${entityName}.${fieldName}: Auto-converting boolean ${value} to integer ${value ? 1 : 0}`);
+                    return value ? 1 : 0;
+                }
+                throw new Error(`Type mismatch for ${entityName}.${fieldName}: Expected integer, got ${actualType} with value ${JSON.stringify(value)}`);
+
+            case "string":
+                // Coerce to string
+                if(actualType === 'string'){
+                    return value;
+                }
+                // Allow auto-conversion from primitives
+                if(['number', 'boolean'].includes(actualType)){
+                    console.warn(`⚠️  Field ${entityName}.${fieldName}: Auto-converting ${actualType} ${value} to string "${String(value)}"`);
+                    return String(value);
+                }
+                throw new Error(`Type mismatch for ${entityName}.${fieldName}: Expected string, got ${actualType} with value ${JSON.stringify(value)}`);
+
+            case "boolean":
+                // Coerce to boolean
+                if(actualType === 'boolean'){
+                    return value;
+                }
+                if(actualType === 'number'){
+                    console.warn(`⚠️  Field ${entityName}.${fieldName}: Auto-converting number ${value} to boolean ${value !== 0}`);
+                    return value !== 0;
+                }
+                if(actualType === 'string'){
+                    const lower = value.toLowerCase().trim();
+                    if(['true', '1', 'yes'].includes(lower)){
+                        console.warn(`⚠️  Field ${entityName}.${fieldName}: Auto-converting string "${value}" to boolean true`);
+                        return true;
+                    }
+                    if(['false', '0', 'no', ''].includes(lower)){
+                        console.warn(`⚠️  Field ${entityName}.${fieldName}: Auto-converting string "${value}" to boolean false`);
+                        return false;
+                    }
+                    throw new Error(`Type mismatch for ${entityName}.${fieldName}: Expected boolean, got string "${value}" which cannot be converted`);
+                }
+                throw new Error(`Type mismatch for ${entityName}.${fieldName}: Expected boolean, got ${actualType} with value ${JSON.stringify(value)}`);
+
+            case "time":
+                // Time fields should be strings or timestamps
+                if(actualType === 'string' || actualType === 'number'){
+                    return value;
+                }
+                throw new Error(`Type mismatch for ${entityName}.${fieldName}: Expected time (string/number), got ${actualType} with value ${JSON.stringify(value)}`);
+
+            default:
+                // For unknown types, allow the value through but warn
+                if(actualType === 'object'){
+                    console.warn(`⚠️  Field ${entityName}.${fieldName}: Setting object value for type "${expectedType}". This may cause issues.`);
+                }
+                return value;
+        }
+    }
+
 
        // return columns and value strings
     _buildSQLInsertObject(fields, modelEntity){
@@ -506,18 +633,25 @@ class SQLLiteEngine {
                 var fieldColumn = "";
                 // check if get function is avaliable if so use that
                 fieldColumn = fields[column];
-                
+
                 if((fieldColumn !== undefined && fieldColumn !== null ) && typeof(fieldColumn) !== "object"){
+                    // 🔥 NEW: Validate and coerce field type before processing
+                    try {
+                        fieldColumn = $that._validateAndCoerceFieldType(fieldColumn, modelEntity[column], modelEntity.__name, column);
+                    } catch(typeError) {
+                        throw new Error(`INSERT failed: ${typeError.message}`);
+                    }
+
                     switch(modelEntity[column].type){
-                        case "string" : 
-                            fieldColumn = `'${$that._santizeSingleQuotes(fields[column], { entityName: modelEntity.__name, fieldName: column })}'`;
+                        case "string" :
+                            fieldColumn = `'${$that._santizeSingleQuotes(fieldColumn, { entityName: modelEntity.__name, fieldName: column })}'`;
                         break;
-                        case "time" : 
+                        case "time" :
                             // Quote time values to prevent blank values from producing malformed SQL
-                            fieldColumn = `'${fields[column]}'`;
+                            fieldColumn = `'${fieldColumn}'`;
                         break;
                     }
-                    
+
                     var relationship = modelEntity[column].relationshipType
                     if(relationship === "belongsTo"){
                         column = modelEntity[column].foreignKey

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "masterrecord",
-  "version": "0.2.31",
+  "version": "0.2.33",
   "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 ",
   "main": "MasterRecord.js",
   "bin": {

package/readme.md

@@ -96,8 +96,14 @@ Backward-compatible rollout tip:
 - Cannot connect to DB: confirm `master=<env>` is set and `env.<env>.json` exists with correct credentials and paths.
 - MySQL type mismatches: the migration engine maps MasterRecord types to SQL types; verify your entity field `type` values are correct.
 
-### Recent improvements (2025-09)
-
+### Recent improvements (2025-10)
+
+- **Type validation and coercion (Entity Framework-style)**:
+  - INSERT and UPDATE operations now validate field types against entity definitions.
+  - Auto-converts compatible types with warnings (e.g., string "4" → integer 4).
+  - Throws clear errors for incompatible types with detailed context.
+  - Prevents silent failures where fields were skipped due to type mismatches.
+  - See [Type Validation](#type-validation) section below for details.
 - Query language and SQL engines:
   - Correct parsing of multi-char operators (>=, <=, ===, !==) and spaced logical operators.
   - Support for grouped OR conditions rendered as parenthesized OR in WHERE across SQLite/MySQL.
@@ -179,6 +185,90 @@ Notes:
 - For large SQLite tables, a rebuild copies data; consider maintenance windows.
 - Use `master=development masterrecord get-migrations AppContext` to inspect migration order.
 
+## Type Validation
+
+MasterRecord now validates and coerces field types during INSERT and UPDATE operations, similar to Entity Framework. This prevents silent failures where fields were skipped due to type mismatches.
+
+### How it works
+
+When you assign a value to an entity field, MasterRecord:
+1. **Validates** the value against the field's type definition
+2. **Auto-converts** compatible types with console warnings
+3. **Throws clear errors** for incompatible types
+
+### Type conversion rules
+
+#### Integer fields (`db.integer()`)
+- ✅ **Accepts**: integer numbers
+- ⚠️ **Auto-converts with warning**:
+  - Float → integer (rounds: `3.7` → `4`)
+  - Valid string → integer (`"42"` → `42`)
+  - Boolean → integer (`true` → `1`, `false` → `0`)
+- ❌ **Throws error**: invalid strings (`"abc"`)
+
+#### String fields (`db.string()`)
+- ✅ **Accepts**: strings
+- ⚠️ **Auto-converts with warning**:
+  - Number → string (`42` → `"42"`)
+  - Boolean → string (`true` → `"true"`)
+- ❌ **Throws error**: objects, arrays
+
+#### Boolean fields (`db.boolean()`)
+- ✅ **Accepts**: booleans
+- ⚠️ **Auto-converts with warning**:
+  - Number → boolean (`0` → `false`, others → `true`)
+  - String → boolean (`"true"/"1"/"yes"` → `true`, `"false"/"0"/"no"/""`→ `false`)
+- ❌ **Throws error**: invalid strings, objects
+
+#### Time fields (`db.time()`, timestamps)
+- ✅ **Accepts**: strings or numbers
+- ❌ **Throws error**: objects, booleans
+
+### Example warnings and errors
+
+**Auto-conversion warning (non-breaking):**
+```javascript
+const chunk = new DocumentChunk();
+chunk.document_id = "4"; // string assigned to integer field
+context.DocumentChunk.add(chunk);
+context.saveChanges();
+```
+Console output:
+```
+⚠️  Field DocumentChunk.document_id: Auto-converting string "4" to integer 4
+```
+
+**Type mismatch error (breaks execution):**
+```javascript
+const chunk = new DocumentChunk();
+chunk.document_id = "invalid"; // non-numeric string
+context.DocumentChunk.add(chunk);
+context.saveChanges(); // throws error
+```
+Error thrown:
+```
+INSERT failed: Type mismatch for DocumentChunk.document_id: Expected integer, got string "invalid" which cannot be converted to a number
+```
+
+### Migration from older versions
+
+If your code relies on implicit type coercion that was previously silent:
+- **No breaking changes**: Compatible types are still auto-converted
+- **New warnings**: You'll see console warnings for auto-conversions
+- **New errors**: Incompatible types that were silently skipped now throw errors
+
+**Recommendation**: Review warnings and fix type mismatches in your code for cleaner, more predictable behavior.
+
+### Benefits
+
+1. **No more silent field skipping**: Previously, if you assigned a string to an integer field, the ORM would silently skip it in the INSERT/UPDATE statement. Now you get immediate feedback.
+
+2. **Clear error messages**: Errors include entity name, field name, expected type, actual type, and the problematic value.
+
+3. **Predictable behavior**: Auto-conversions match common patterns (e.g., database IDs returned as strings from some drivers are converted to integers).
+
+4. **Better debugging**: Type issues are caught at save time, not when you query the data later.
+
 ## Multi-context (multi-database) projects
 
 When your project defines multiple Context files (e.g., `userContext.js`, `modelContext.js`, `mailContext.js`, `chatContext.js`) across different packages or feature directories, MasterRecord can auto-detect and operate on all of them.