masterrecord 0.3.0 → 0.3.1

package/.claude/settings.local.json

@@ -27,7 +27,8 @@
       "Bash(git commit:*)",
       "Bash(git push)",
       "Bash(find:*)",
-      "Bash(npm install)"
+      "Bash(npm install)",
+      "Bash(ls:*)"
     ],
     "deny": [],
     "ask": []

package/SQLLiteEngine.js

@@ -810,15 +810,12 @@ class SQLLiteEngine {
                     } catch(typeError) {
                         throw new Error(`UPDATE failed: ${typeError.message}`);
                     }
-                    var bool;
-                    if(model.__entity[dirtyFields[column]].valueConversion){
-                        bool = tools.convertBooleanToNumber(boolValue);
-                    }
-                    else{
-                        bool = boolValue;
-                    }
+
+                    // Convert to database-specific format (e.g., boolean → 1/0 for SQLite)
+                    boolValue = $that._convertValueForDatabase(boolValue, model.__entity[dirtyFields[column]].type);
+
                     sqlParts.push(`[${dirtyFields[column]}] = ?`);
-                    params.push(bool);
+                    params.push(boolValue);
                 break;
                 case "time":
                     var timeValue = model[dirtyFields[column]];
@@ -921,7 +918,7 @@ class SQLLiteEngine {
                 throw new Error(`Type mismatch for ${entityName}.${fieldName}: Expected string, got ${actualType} with value ${JSON.stringify(value)}`);
 
             case "boolean":
-                // Coerce to boolean
+                // Coerce to boolean (then convert for database)
                 if(actualType === 'boolean'){
                     return value;
                 }
@@ -959,6 +956,27 @@ class SQLLiteEngine {
         }
     }
 
+    /**
+     * Convert validated value to database-specific format
+     * Modern ORM pattern: transparent database-specific conversions
+     *
+     * @param {*} value - Already validated value
+     * @param {string} fieldType - Field type from entity definition
+     * @returns {*} Database-ready value
+     */
+    _convertValueForDatabase(value, fieldType){
+        if(value === undefined || value === null){
+            return value;
+        }
+
+        // SQLite boolean conversion: JavaScript boolean → INTEGER (1/0)
+        if(fieldType === 'boolean' && typeof value === 'boolean'){
+            return value ? 1 : 0;
+        }
+
+        return value;
+    }
+
 
        // return columns and value strings
     _buildSQLInsertObject(fields, modelEntity){
@@ -1055,6 +1073,9 @@ class SQLLiteEngine {
                         throw new Error(`INSERT failed: ${typeError.message}`);
                     }
 
+                    // Convert to database-specific format (e.g., boolean → 1/0 for SQLite)
+                    fieldColumn = $that._convertValueForDatabase(fieldColumn, modelEntity[column].type);
+
                     var relationship = modelEntity[column].relationshipType;
                     var actualColumn = relationship === "belongsTo" ? modelEntity[column].foreignKey : column;
 

package/context.js

@@ -456,10 +456,10 @@ class context {
                     for (var model in tracked) {
                         var currentModel = tracked[model];
                             switch(currentModel.__state) {
-                                case "insert": 
+                                case "insert":
                                     var insert = new insertManager(this._SQLEngine, this._isModelValid, this.__entities);
                                     insert.init(currentModel);
-                                    
+
                                 break;
                                 case "modified":
                                     if(currentModel.__dirtyFields.length > 0){
@@ -485,13 +485,53 @@ class context {
                                 case "delete":
                                     var deleteObject = new deleteManager(this._SQLEngine, this.__entities);
                                     deleteObject.init(currentModel);
-                                    
+
                                 break;
-                            } 
+                            }
                     }
                     this.__clearErrorHandler();
                     //this._SQLEngine.endTransaction();
                 }
+                if(this.isPostgres){
+                    // PostgreSQL async operations (no transaction control here)
+                    for (var model in tracked) {
+                        var currentModel = tracked[model];
+                            switch(currentModel.__state) {
+                                case "insert":
+                                    var insert = new insertManager(this._SQLEngine, this._isModelValid, this.__entities);
+                                    insert.init(currentModel);
+
+                                break;
+                                case "modified":
+                                    if(currentModel.__dirtyFields.length > 0){
+                                        var cleanCurrentModel = tools.removePrimarykeyandVirtual(currentModel, currentModel._entity);
+                                        // Use NEW SECURE parameterized version
+                                        var argu = this._SQLEngine._buildSQLEqualToParameterized(cleanCurrentModel);
+                                        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");
+                                    }
+
+                                // code block
+                                break;
+                                case "delete":
+                                    var deleteObject = new deleteManager(this._SQLEngine, this.__entities);
+                                    deleteObject.init(currentModel);
+
+                                break;
+                            }
+                    }
+                    this.__clearErrorHandler();
+                }
             }
             else{
                 console.log("save changes has no tracked entities");

package/mySQLEngine.js

@@ -629,6 +629,7 @@ class SQLLiteEngine {
                     catch(transformError) { throw new Error(`UPDATE failed: ${transformError.message}`); }
                     try { boolValue = $that._validateAndCoerceFieldType(boolValue, model.__entity[dirtyFields[column]], model.__entity.__name, dirtyFields[column]); }
                     catch(typeError) { throw new Error(`UPDATE failed: ${typeError.message}`); }
+                    boolValue = $that._convertValueForDatabase(boolValue, model.__entity[dirtyFields[column]].type);
                     var bool = model.__entity[dirtyFields[column]].valueConversion ? tools.convertBooleanToNumber(boolValue) : boolValue;
                     sqlParts.push(`${dirtyFields[column]} = ?`);
                     params.push(bool);
@@ -677,6 +678,8 @@ class SQLLiteEngine {
                     try { fieldColumn = $that._validateAndCoerceFieldType(fieldColumn, modelEntity[column], modelEntity.__name, column); }
                     catch(typeError) { throw new Error(`INSERT failed: ${typeError.message}`); }
 
+                    fieldColumn = $that._convertValueForDatabase(fieldColumn, modelEntity[column].type);
+
                     var relationship = modelEntity[column].relationshipType;
                     var actualColumn = relationship === "belongsTo" ? modelEntity[column].foreignKey : column;
                     columnNames.push(actualColumn);
@@ -707,6 +710,27 @@ class SQLLiteEngine {
         }
     }
 
+    /**
+     * Convert validated value to database-specific format
+     * Modern ORM pattern: transparent database-specific conversions
+     *
+     * @param {*} value - Already validated value
+     * @param {string} fieldType - Field type from entity definition
+     * @returns {*} Database-ready value
+     */
+    _convertValueForDatabase(value, fieldType){
+        if(value === undefined || value === null){
+            return value;
+        }
+
+        // MySQL boolean conversion: JavaScript boolean → TINYINT (1/0)
+        if(fieldType === 'boolean' && typeof value === 'boolean'){
+            return value ? 1 : 0;
+        }
+
+        return value;
+    }
+
     /**
      * Validate and coerce field value to match entity type definition
      * Throws detailed error if type cannot be coerced

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "masterrecord",
-  "version": "0.3.0",
+  "version": "0.3.1",
   "description": "An Object-relational mapping for the Master framework. Master Record connects classes to relational database tables to establish a database with almost zero-configuration ",
   "main": "MasterRecord.js",
   "bin": {

package/postgresEngine.js

@@ -43,10 +43,13 @@ class postgresEngine {
      * UPDATE with parameterized query
      */
     async update(query) {
-        if (query.arg && query.arg.query && query.arg.params) {
-            // Parameterized UPDATE
+        // Use parameterized query for security
+        // query.arg now contains {query, params} from _buildSQLEqualToParameterized
+        if (query.arg && typeof query.arg === 'object' && query.arg.query && query.arg.params) {
+            const sqlQuery = `UPDATE ${query.tableName} SET ${query.arg.query} WHERE ${query.tableName}.${query.primaryKey} = $${query.arg.params.length + 1}`;
+            // Add primaryKeyValue to params array
             const params = [...query.arg.params, query.primaryKeyValue];
-            return await this._runWithParams(query.arg.query, params);
+            return await this._runWithParams(sqlQuery, params);
         } else {
             // Fallback for legacy support
             const sqlQuery = `UPDATE ${query.tableName} SET ${query.arg} WHERE ${query.tableName}.${query.primaryKey} = $1`;
@@ -381,6 +384,152 @@ class postgresEngine {
         return name;
     }
 
+    /**
+     * Build SQL SET clause with parameterized queries for UPDATE (PostgreSQL)
+     * Returns {query: "column1 = $1, column2 = $2", params: [value1, value2]}
+     */
+    _buildSQLEqualToParameterized(model) {
+        const $that = this;
+        const sqlParts = [];
+        const params = [];
+        const dirtyFields = model.__dirtyFields;
+        let paramIndex = 1;
+
+        for (let column in dirtyFields) {
+            const fieldName = dirtyFields[column];
+            const entityDef = model.__entity[fieldName];
+
+            // Check for required fields
+            if (entityDef && entityDef.nullable === false && entityDef.primary !== true) {
+                let persistedValue;
+                switch (entityDef.type) {
+                    case "integer":
+                        persistedValue = model["_" + fieldName];
+                        break;
+                    case "belongsTo":
+                        persistedValue = model["_" + fieldName] !== undefined ? model["_" + fieldName] : model[fieldName];
+                        break;
+                    default:
+                        persistedValue = model[fieldName];
+                }
+                const isEmptyString = (typeof persistedValue === 'string') && (persistedValue.trim() === '');
+                if (persistedValue === undefined || persistedValue === null || isEmptyString) {
+                    throw new Error(`Entity ${model.__entity.__name} column ${fieldName} is a required Field`);
+                }
+            }
+
+            let type = model.__entity[dirtyFields[column]].type;
+            if (model.__entity[dirtyFields[column]].relationshipType === "belongsTo") {
+                type = "belongsTo";
+            }
+
+            switch (type) {
+                case "belongsTo":
+                    const foreignKey = model.__entity[dirtyFields[column]].foreignKey;
+                    let fkValue = model[dirtyFields[column]];
+                    // Apply toDatabase transformer
+                    try {
+                        fkValue = FieldTransformer.toDatabase(fkValue, model.__entity[dirtyFields[column]], model.__entity.__name, dirtyFields[column]);
+                    } catch (transformError) {
+                        throw new Error(`UPDATE failed: ${transformError.message}`);
+                    }
+                    try {
+                        fkValue = $that._validateAndCoerceFieldType(fkValue, model.__entity[dirtyFields[column]], model.__entity.__name, dirtyFields[column]);
+                    } catch (typeError) {
+                        throw new Error(`UPDATE failed: ${typeError.message}`);
+                    }
+                    fkValue = $that._convertValueForDatabase(fkValue, model.__entity[dirtyFields[column]].type);
+                    const fore = `_${dirtyFields[column]}`;
+                    sqlParts.push(`${foreignKey} = $${paramIndex++}`);
+                    params.push(model[fore]);
+                    break;
+
+                case "integer":
+                    let intValue = model["_" + dirtyFields[column]];
+                    // Apply toDatabase transformer
+                    try {
+                        intValue = FieldTransformer.toDatabase(intValue, model.__entity[dirtyFields[column]], model.__entity.__name, dirtyFields[column]);
+                    } catch (transformError) {
+                        throw new Error(`UPDATE failed: ${transformError.message}`);
+                    }
+                    try {
+                        intValue = $that._validateAndCoerceFieldType(intValue, model.__entity[dirtyFields[column]], model.__entity.__name, dirtyFields[column]);
+                    } catch (typeError) {
+                        throw new Error(`UPDATE failed: ${typeError.message}`);
+                    }
+                    intValue = $that._convertValueForDatabase(intValue, model.__entity[dirtyFields[column]].type);
+                    sqlParts.push(`${dirtyFields[column]} = $${paramIndex++}`);
+                    params.push(intValue);
+                    break;
+
+                case "string":
+                    let strValue = model[dirtyFields[column]];
+                    // Apply toDatabase transformer
+                    try {
+                        strValue = FieldTransformer.toDatabase(strValue, model.__entity[dirtyFields[column]], model.__entity.__name, dirtyFields[column]);
+                    } catch (transformError) {
+                        throw new Error(`UPDATE failed: ${transformError.message}`);
+                    }
+                    try {
+                        strValue = $that._validateAndCoerceFieldType(strValue, model.__entity[dirtyFields[column]], model.__entity.__name, dirtyFields[column]);
+                    } catch (typeError) {
+                        throw new Error(`UPDATE failed: ${typeError.message}`);
+                    }
+                    strValue = $that._convertValueForDatabase(strValue, model.__entity[dirtyFields[column]].type);
+                    sqlParts.push(`${dirtyFields[column]} = $${paramIndex++}`);
+                    params.push(strValue);
+                    break;
+
+                case "boolean":
+                    let boolValue = model[dirtyFields[column]];
+                    // Apply toDatabase transformer
+                    try {
+                        boolValue = FieldTransformer.toDatabase(boolValue, model.__entity[dirtyFields[column]], model.__entity.__name, dirtyFields[column]);
+                    } catch (transformError) {
+                        throw new Error(`UPDATE failed: ${transformError.message}`);
+                    }
+                    try {
+                        boolValue = $that._validateAndCoerceFieldType(boolValue, model.__entity[dirtyFields[column]], model.__entity.__name, dirtyFields[column]);
+                    } catch (typeError) {
+                        throw new Error(`UPDATE failed: ${typeError.message}`);
+                    }
+                    boolValue = $that._convertValueForDatabase(boolValue, model.__entity[dirtyFields[column]].type);
+                    sqlParts.push(`${dirtyFields[column]} = $${paramIndex++}`);
+                    params.push(boolValue);
+                    break;
+
+                case "time":
+                    let timeValue = model[dirtyFields[column]];
+                    // Apply toDatabase transformer
+                    try {
+                        timeValue = FieldTransformer.toDatabase(timeValue, model.__entity[dirtyFields[column]], model.__entity.__name, dirtyFields[column]);
+                    } catch (transformError) {
+                        throw new Error(`UPDATE failed: ${transformError.message}`);
+                    }
+                    try {
+                        timeValue = $that._validateAndCoerceFieldType(timeValue, model.__entity[dirtyFields[column]], model.__entity.__name, dirtyFields[column]);
+                    } catch (typeError) {
+                        throw new Error(`UPDATE failed: ${typeError.message}`);
+                    }
+                    timeValue = $that._convertValueForDatabase(timeValue, model.__entity[dirtyFields[column]].type);
+                    sqlParts.push(`${dirtyFields[column]} = $${paramIndex++}`);
+                    params.push(timeValue);
+                    break;
+
+                case "hasMany":
+                    sqlParts.push(`${dirtyFields[column]} = $${paramIndex++}`);
+                    params.push(model[dirtyFields[column]]);
+                    break;
+
+                default:
+                    sqlParts.push(`${dirtyFields[column]} = $${paramIndex++}`);
+                    params.push(model[dirtyFields[column]]);
+            }
+        }
+
+        return sqlParts.length > 0 ? { query: sqlParts.join(', '), params: params } : -1;
+    }
+
     /**
      * Build parameterized INSERT object for PostgreSQL
      * Uses $1, $2, $3... instead of ?
@@ -410,6 +559,9 @@ class postgresEngine {
                         throw new Error(`INSERT failed: ${typeError.message}`);
                     }
 
+                    // Convert to database-specific format
+                    fieldColumn = $that._convertValueForDatabase(fieldColumn, modelEntity[column].type);
+
                     // Skip auto-increment primary keys
                     if (modelEntity[column].auto !== true) {
                         columnNames.push(column);
@@ -506,6 +658,28 @@ class postgresEngine {
         }
     }
 
+    /**
+     * Convert validated value to database-specific format
+     * Modern ORM pattern: transparent database-specific conversions
+     *
+     * @param {*} value - Already validated value
+     * @param {string} fieldType - Field type from entity definition
+     * @returns {*} Database-ready value
+     */
+    _convertValueForDatabase(value, fieldType){
+        if(value === undefined || value === null){
+            return value;
+        }
+
+        // PostgreSQL accepts native booleans, but we convert to 1/0 for consistency
+        // The pg driver will convert to PostgreSQL TRUE/FALSE
+        if(fieldType === 'boolean' && typeof value === 'boolean'){
+            return value ? 1 : 0;
+        }
+
+        return value;
+    }
+
     /**
      * Execute parameterized query with pg library
      */