masterrecord 0.2.32 → 0.2.33

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.32",
+  "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.