masterrecord 0.3.16 → 0.3.18

package/mySQLEngine.js

@@ -1,1105 +0,0 @@
-// version : 0.0.9
-
-var tools =  require('masterrecord/Tools');
-var util = require('util');
-var FieldTransformer = require('masterrecord/Entity/fieldTransformer');
-
-class SQLLiteEngine {
-
-    unsupportedWords = ["order"]
-
-    update(query){
-        // Security: ONLY use parameterized queries - no fallback to string concatenation
-        // query.arg must contain {sql, params} from _buildSQLEqualToParameterized
-        if(!query.arg || typeof query.arg !== 'object' || !query.arg.sql || !query.arg.params){
-            throw new Error('UPDATE failed: Invalid parameterized query structure. Check entity definition.');
-        }
-
-        var sqlQuery = ` UPDATE ${query.tableName} SET ${query.arg.sql} WHERE ${query.tableName}.${query.primaryKey} = ?`;
-        // Add primaryKeyValue to params array
-        var params = [...query.arg.params, query.primaryKeyValue];
-        return this._runWithParams(sqlQuery, params);
-    }
-
-    delete(queryObject){
-       var sqlObject = this._buildDeleteObject(queryObject);
-       // Use parameterized query to prevent SQL injection
-       var sqlQuery = `DELETE FROM ${sqlObject.tableName} WHERE ${sqlObject.tableName}.${sqlObject.primaryKey} = ?`;
-       return this._runWithParams(sqlQuery, [sqlObject.value]);
-    }
-
-    insert(queryObject){
-        // Use NEW SECURE parameterized version
-        var sqlObject = this._buildSQLInsertObjectParameterized(queryObject, queryObject.__entity);
-        if(sqlObject === -1){
-            throw new Error('INSERT failed: No columns to insert');
-        }
-        var query = `INSERT INTO ${sqlObject.tableName} (${sqlObject.columns}) VALUES (${sqlObject.placeholders})`;
-        var queryObj = this._runWithParams(query, sqlObject.params);
-        // return
-        var open = {
-            "id": queryObj.insertId
-        };
-        return open;
-    }
-
-    /**
-     * Batch insert using MySQL's multi-value INSERT
-     * INSERT INTO table (col1, col2) VALUES (?, ?), (?, ?), (?, ?)
-     */
-    bulkInsert(entities) {
-        if (!entities || entities.length === 0) return [];
-
-        // Group by table name
-        const byTable = {};
-        for (const entity of entities) {
-            const tableName = entity.__entity.__name;
-            if (!byTable[tableName]) byTable[tableName] = [];
-            byTable[tableName].push(entity);
-        }
-
-        const results = [];
-        for (const tableName in byTable) {
-            const tableEntities = byTable[tableName];
-
-            // Build multi-value INSERT
-            const first = this._buildSQLInsertObjectParameterized(tableEntities[0], tableEntities[0].__entity);
-            const allParams = [...first.params];
-            const valueGroups = [`(${first.placeholders})`];
-
-            for (let i = 1; i < tableEntities.length; i++) {
-                const sqlObj = this._buildSQLInsertObjectParameterized(tableEntities[i], tableEntities[i].__entity);
-                valueGroups.push(`(${sqlObj.placeholders})`);
-                allParams.push(...sqlObj.params);
-            }
-
-            const query = `INSERT INTO \`${first.tableName}\` (${first.columns}) VALUES ${valueGroups.join(', ')}`;
-            const result = this._runWithParams(query, allParams);
-            results.push(result);
-        }
-
-        return results;
-    }
-
-    /**
-     * Batch update (execute in sequence for MySQL)
-     */
-    bulkUpdate(updateQueries) {
-        if (!updateQueries || updateQueries.length === 0) return;
-
-        for (const query of updateQueries) {
-            this.update(query);
-        }
-    }
-
-    /**
-     * Batch delete using WHERE IN
-     */
-    bulkDelete(tableName, ids) {
-        if (!ids || ids.length === 0) return;
-
-        const placeholders = ids.map(() => '?').join(', ');
-        const query = `DELETE FROM \`${tableName}\` WHERE id IN (${placeholders})`;
-        return this._runWithParams(query, ids);
-    }
-
-    get(query, entity, context){
-        var queryString = {};
-        try {
-            if(query.raw){
-                queryString.query = query.raw;
-            }
-            else{
-                queryString = this.buildQuery(query, entity, context);
-            }
-            if(queryString.query){
-                // Get parameters from query script
-                const params = query.parameters ? query.parameters.getParams() : [];
-                if (process.env.LOG_SQL === 'true' || process.env.NODE_ENV !== 'production') {
-                    console.debug("[SQL]", queryString.query);
-                    console.debug("[Params]", params);
-                }
-                this.db.connect(this.db);
-                const result = this.db.query(queryString.query, params);
-                if (process.env.LOG_SQL === 'true' || process.env.NODE_ENV !== 'production') {
-                    console.debug("results:", result);
-                }
-                return result;
-            }
-            return null;
-        } catch (err) {
-            console.error(err);
-            return null;
-        }
-    }
-
-    getCount(queryObject, entity, context){
-        var query = queryObject.script;
-        var queryString = {};
-        try {
-            if(query.raw){
-                queryString.query = query.raw;
-            }
-            else{
-                queryString = this.buildQuery(query, entity, context);
-            }
-            if(queryString.query){
-                var queryCount = queryObject.count(queryString.query)
-                // Get parameters from query script
-                const params = query.parameters ? query.parameters.getParams() : [];
-                if (process.env.LOG_SQL === 'true' || process.env.NODE_ENV !== 'production') {
-                    console.debug("[SQL]", queryCount);
-                    console.debug("[Params]", params);
-                }
-                this.db.connect(this.db);
-                var queryReturn = this.db.query(queryCount, params);
-                return queryReturn[0]; // MySQL returns array, get first row
-            }
-            return null;
-        } catch (err) {
-            console.error(err);
-            return null;
-        }
-    }
-
-    all(query, entity, context){
-        var queryString = {};
-        try {
-            if(query.raw){
-                queryString.query = query.raw;
-            }
-            else{
-                queryString = this.buildQuery(query, entity, context);
-            }
-            if(queryString.query){
-                // Get parameters from query script
-                const params = query.parameters ? query.parameters.getParams() : [];
-                if (process.env.LOG_SQL === 'true' || process.env.NODE_ENV !== 'production') {
-                    console.debug("[SQL]", queryString.query);
-                    console.debug("[Params]", params);
-                }
-                this.db.connect(this.db);
-                const result = this.db.query(queryString.query, params);
-                if (process.env.LOG_SQL === 'true' || process.env.NODE_ENV !== 'production') {
-                    console.debug("results:", result);
-                }
-                return result;
-            }
-            return null;
-        } catch (err) {
-            console.error(err);
-            return null;
-        }
-    }
-
-    // Introspection helpers
-    tableExists(tableName){
-        try{
-            const sql = `SELECT TABLE_NAME FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_SCHEMA = DATABASE() AND TABLE_NAME = ?`;
-            this.db.connect(this.db);
-            const res = this.db.query(sql, [tableName]);
-            return Array.isArray(res) ? res.length > 0 : !!res?.length;
-        }catch(_){ return false; }
-    }
-
-    getTableInfo(tableName){
-        try{
-            const sql = `SELECT COLUMN_NAME as name, COLUMN_DEFAULT as dflt_value, IS_NULLABLE as is_nullable, DATA_TYPE as data_type FROM INFORMATION_SCHEMA.COLUMNS WHERE TABLE_SCHEMA = DATABASE() AND TABLE_NAME = ?`;
-            this.db.connect(this.db);
-            const res = this.db.query(sql, [tableName]);
-            return res || [];
-        }catch(_){ return []; }
-    }
-
-
-    buildQuery(query, entity, context){
-
-        var queryObject = {};
-        if(entity){
-            queryObject.entity = this.getEntity(entity.__name, query.entityMap);
-            queryObject.select = this.buildSelect(query, entity);
-            queryObject.from = this.buildFrom(query, entity);
-            queryObject.include = this.buildInclude(query, entity, context, queryObject);
-            queryObject.where = this.buildWhere(query, entity);
-    
-            var queryString = `${queryObject.select} ${queryObject.from} ${queryObject.include} ${queryObject.where}`;
-            return { 
-                    query : queryString,
-                    entity : this.getEntity(entity.__name, query.entityMap)
-            }
-        }
-        else{
-            console.log("Error: Entity object is blank");
-        }
-       
-
-    }
-
-    buildWhere(query, mainQuery){
-		var whereEntity = query.where;
-		var $that = this;
-		if(!whereEntity){
-			return "";
-		}
-
-		var entityAlias = this.getEntity(query.parentName, query.entityMap);
-		var item = whereEntity[query.parentName].query;
-		var exprs = item.expressions || [];
-
-		function exprToSql(expr){
-			var field = expr.field.toLowerCase();
-			var ent = entityAlias;
-			if(mainQuery[field]){
-				if(mainQuery[field].isNavigational){
-					ent = $that.getEntity(field, query.entityMap);
-					if(item.fields && item.fields[1]){
-						field = item.fields[1];
-					}
-				}
-			}
-			let func = expr.func;
-			let arg = expr.arg;
-			if((!func && typeof arg === 'undefined')){
-				return null;
-			}
-			// Removed fallback that coerced 'exists' with an argument to '='
-			// Bare field or !field: interpret as IS [NOT] NULL
-			if(func === 'exists' && typeof arg === 'undefined'){
-				const isNull = expr.negate === true; // '!field' -> IS NULL
-				return `${ent}.${field}  is ${isNull ? '' : 'not '}null`;
-			}
-			if(arg === "null"){
-				if(func === "=") func = "is";
-				if(func === "!=") func = "is not";
-				return `${ent}.${field}  ${func} ${arg}`;
-			}
-			if(func === "IN"){
-				return `${ent}.${field}  ${func} ${arg}`;
-			}
-			// Check if arg is a parameterized placeholder (? for MySQL/SQLite, $1/$2/etc for Postgres)
-			var isPlaceholder = (arg === '?' || /^\$\d+$/.test(arg));
-			if(isPlaceholder){
-				// Don't quote placeholders - they must remain as bare ? or $1
-				return `${ent}.${field}  ${func} ${arg}`;
-			}
-            var safeArg = (typeof arg === 'string' || arg instanceof String)
-                ? $that._santizeSingleQuotes(arg, { entityName: ent, fieldName: field })
-                : String(arg);
-            return `${ent}.${field}  ${func} '${safeArg}'`;
-		}
-
-		const pieces = [];
-		for(let i = 0; i < exprs.length; i++){
-			const e = exprs[i];
-			if(e.group){
-				const gid = e.group;
-				const orParts = [];
-				while(i < exprs.length && exprs[i].group === gid){
-					const sql = exprToSql(exprs[i]);
-					if(sql){ orParts.push(sql); }
-					i++;
-				}
-				i--; // compensate for loop increment
-				if(orParts.length > 0){
-					pieces.push(`(${orParts.join(" or ")})`);
-				}
-			}else{
-				const sql = exprToSql(e);
-				if(sql){ pieces.push(sql); }
-			}
-		}
-
-		if(pieces.length === 0){
-			return "";
-		}
-		return `WHERE ${pieces.join(" and ")}`;
-	}
-
-    buildInclude( query, entity, context){
-        const includeQueries = [];
-        for (let part in query.include) {
-            var includeEntity = query.include[part];
-            var $that = this;
-            if(includeEntity){
-                var parentObj = includeEntity[query.parentName];
-                var currentContext = "";
-                if(includeEntity.selectFields){
-                    currentContext = context[tools.capitalizeFirstLetter(includeEntity.selectFields[0])];
-                }
-
-                if(parentObj){
-                    parentObj.entityMap = query.entityMap;
-                    var foreignKey = $that.getForeignKey(entity.__name, currentContext.__entity);
-                    var mainPrimaryKey = $that.getPrimarykey(entity);
-                    var mainEntity = $that.getEntity(entity.__name, query.entityMap);
-                    if(currentContext.__entity[entity.__name].type === "hasManyThrough"){
-                        var foreignTable = tools.capitalizeFirstLetter(currentContext.__entity[entity.__name].foreignTable); //to uppercase letter
-                        foreignKey = $that.getPrimarykey(currentContext.__entity);
-                        mainPrimaryKey = context[foreignTable].__entity[currentContext.__entity.__name].foreignKey;
-                        var mainEntity = $that.getEntity(foreignTable,query.entityMap);
-                    }
-                    // add foreign key to select so that it picks it up
-                    if(parentObj.select){
-                        parentObj.select.selectFields.push(foreignKey);
-                    }else{
-                        parentObj.select = {};
-                        parentObj.select.selectFields = [];
-                        parentObj.select.selectFields.push(foreignKey);
-                    }
-
-                    var innerQuery = $that.buildQuery(parentObj, currentContext.__entity, context);
-
-                    includeQueries.push(`LEFT JOIN (${innerQuery.query}) AS ${innerQuery.entity} ON ${ mainEntity}.${mainPrimaryKey} = ${innerQuery.entity}.${foreignKey}`);
-
-                }
-            }
-        }
-        return includeQueries.join(' ');
-    }
-
-    buildFrom(query, entity){
-        var entityName = this.getEntity(entity.__name, query.entityMap);
-        if(entityName ){
-            return `FROM ${entity.__name } AS ${entityName}`;
-        }
-        else{ return "" }
-    }
-
-    buildSelect(query, entity){
-        // this means that there is a select statement
-        var select = "SELECT";
-        const arr = [];
-        var $that = this;
-        if(query.select){
-            for (const item in query.select.selectFields) {
-                arr.push(`${$that.getEntity(entity.__name, query.entityMap)}.${query.select.selectFields[item]}`);
-            };
-
-        }
-        else{
-            var entityList = this.getEntityList(entity);
-            for (const item in entityList) {
-                arr.push(`${$that.getEntity(entity.__name, query.entityMap)}.${entityList[item]}`);
-            };
-        }
-        return `${select} ${arr.join(', ')} `;
-    }
-
-    getForeignKey(name, entity){
-        if(entity && name){
-           return entity[name].foreignKey;
-        }
-    }
-
-    getPrimarykey(entity){
-            for (const item in entity) {
-                if(entity[item].primary){
-                    if(entity[item].primary === true){
-                        return entity[item].name;
-                    }
-                }
-            };
-    }
-
-    getForeignTable(name, entity){
-        if(entity && name){
-           return entity[name].foreignTable;
-        }
-    }
-
-    getInclude(name, query){
-        var include = query.include;
-        if(include){
-            for (let part in include) {
-                if(tools.capitalizeFirstLetter(include[part].selectFields[0]) === name){
-                    return include[part];
-                }
-            }
-        }
-        else{
-            return "";
-        }
-    }
-
-    getEntity(name, maps){
-        for (let item in maps) {
-            var map = maps[item];
-            if(tools.capitalizeFirstLetter(name) === map.name){
-                return map.entity
-            }
-        }
-        return "";
-    }
-
-    // return a list of entity names and skip foreign keys and underscore.
-    getEntityList(entity){
-        var entitiesList = [];
-        var $that = this;
-        for (var ent in entity) {
-                if(!ent.startsWith("_")){
-                    if(!entity[ent].foreignKey){
-                        if(entity[ent].relationshipTable){
-                            if($that.chechUnsupportedWords(entity[ent].relationshipTable)){
-                                entitiesList.push(`'${entity[ent].relationshipTable}'`);
-                            }
-                            else{
-                                entitiesList.push(entity[ent].relationshipTable);
-                            }
-                        }
-                        else{
-                            if($that.chechUnsupportedWords(ent)){
-                                entitiesList.push(`'${ent}'`);
-                            }
-                            else{
-                                entitiesList.push(ent);
-                            }
-                        }
-                    }
-                    else{
-                        
-                        if(entity[ent].relationshipType === "belongsTo"){
-                            var name = entity[ent].foreignKey;
-                            if($that.chechUnsupportedWords(name)){
-                                entitiesList.push(`'${name}'`);
-                                //entitiesList.push(`'${ent}'`);
-                            }
-                            else{
-                                entitiesList.push(name);
-                                //entitiesList.push(ent);
-                            }
-                        }
-                        
-                    }
-                }
-            }
-        // Ensure primary key is always included in SELECT list
-        try{
-            const pk = this.getPrimarykey(entity);
-            if(pk){
-                const hasPk = entitiesList.indexOf(pk) !== -1 || entitiesList.indexOf(`\`${pk}\``) !== -1;
-                if(!hasPk){ entitiesList.unshift(pk); }
-            }
-        }catch(_){ /* ignore */ }
-        return entitiesList
-    }
-
-    chechUnsupportedWords(word){
-        for (var item in this.unsupportedWords) {
-            var text = this.unsupportedWords[item];
-            if(text === word){
-                return true
-            }
-        }
-        return false;
-    }
-
-    startTransaction(){
-        this.db.prepare('BEGIN').run();
-    }
-
-    endTransaction(){
-        this.db.prepare('COMMIT').run();
-    }
-
-    errorTransaction(){
-        this.db.prepare('ROLLBACK').run();
-    }
-
-    _buildSQLEqualTo(model){
-        var $that = this;
-        var argument = null;
-        var dirtyFields = model.__dirtyFields;
-        
-        for (var column in dirtyFields) {
-            // Validate non-nullable constraints on updates
-            var fieldName = dirtyFields[column];
-            var entityDef = model.__entity[fieldName];
-            if(entityDef && entityDef.nullable === false && entityDef.primary !== true){
-                // Determine the value that will actually be persisted for this field
-                var persistedValue;
-                switch(entityDef.type){
-                    case "integer":
-                        persistedValue = model["_" + fieldName];
-                    break;
-                    case "belongsTo":
-                        persistedValue = model["_" + fieldName] !== undefined ? model["_" + fieldName] : model[fieldName];
-                    break;
-                    default:
-                        persistedValue = model[fieldName];
-                }
-                var isEmptyString = (typeof persistedValue === 'string') && (persistedValue.trim() === '');
-                if(persistedValue === undefined || persistedValue === null || isEmptyString){
-                    throw `Entity ${model.__entity.__name} column ${fieldName} is a required Field`;
-                }
-            }
-            // TODO Boolean value is a string with a letter
-            var type = model.__entity[dirtyFields[column]].type;
-            
-            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]];
-                    // 🔥 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]}`];
-                    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" :
-                    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 ('')
-                    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" :
-                    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]]}',`;
-            }
-        }
-       if(argument){
-            return argument.replace(/,\s*$/, "");
-        }
-        else{
-            return -1;
-        }
-    }
-
-    boolType(type){
-        var jj = String(type);
-        switch(jj) {
-            case "true":
-                return 1
-              break;
-              case "false":
-                return 0
-              break;
-              default:
-                return type;
-        }
-    }
-
-    
-    _buildDeleteObject(currentModel){
-        var primaryKey = currentModel.__Key === undefined ? tools.getPrimaryKeyObject(currentModel.__entity) : currentModel.__Key;
-        var value = currentModel.__value === undefined ? currentModel[primaryKey] : currentModel.__value;
-        var tableName = currentModel.__tableName === undefined ? currentModel.__entity.__name : currentModel.__tableName;
-        return {tableName: tableName, primaryKey : primaryKey, value : value};
-    }
-
-    /**
-     * NEW SECURE VERSION: Build SQL SET clause with parameterized queries (MySQL)
-     * Returns {sql: "column1 = ?, column2 = ?", params: [value1, value2]}
-     */
-    _buildSQLEqualToParameterized(model){
-        var $that = this;
-        var sqlParts = [];
-        var params = [];
-        var dirtyFields = model.__dirtyFields;
-
-        for (var column in dirtyFields) {
-            var fieldName = dirtyFields[column];
-            var entityDef = model.__entity[fieldName];
-            if(entityDef && entityDef.nullable === false && entityDef.primary !== true){
-                var persistedValue;
-                switch(entityDef.type){
-                    case "integer": persistedValue = model["_" + fieldName]; break;
-                    case "belongsTo": persistedValue = model["_" + fieldName] !== undefined ? model["_" + fieldName] : model[fieldName]; break;
-                    default: persistedValue = model[fieldName];
-                }
-                var isEmptyString = (typeof persistedValue === 'string') && (persistedValue.trim() === '');
-                if(persistedValue === undefined || persistedValue === null || isEmptyString){
-                    throw `Entity ${model.__entity.__name} column ${fieldName} is a required Field`;
-                }
-            }
-
-            var 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}`); }
-                    var fore = `_${dirtyFields[column]}`;
-                    sqlParts.push(`${foreignKey} = ?`);
-                    params.push(model[fore]);
-                break;
-                case "integer":
-                    var 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}`); }
-                    sqlParts.push(`${dirtyFields[column]} = ?`);
-                    params.push(intValue);
-                break;
-                case "string":
-                    var 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}`); }
-                    sqlParts.push(`${dirtyFields[column]} = ?`);
-                    params.push(strValue);
-                break;
-                case "boolean":
-                    var 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);
-                    var bool = model.__entity[dirtyFields[column]].valueConversion ? tools.convertBooleanToNumber(boolValue) : boolValue;
-                    sqlParts.push(`${dirtyFields[column]} = ?`);
-                    params.push(bool);
-                break;
-                case "time":
-                    var 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}`); }
-                    sqlParts.push(`${dirtyFields[column]} = ?`);
-                    params.push(timeValue);
-                break;
-                case "hasMany":
-                    sqlParts.push(`${dirtyFields[column]} = ?`);
-                    params.push(model[dirtyFields[column]]);
-                break;
-                default:
-                    sqlParts.push(`${dirtyFields[column]} = ?`);
-                    params.push(model[dirtyFields[column]]);
-            }
-        }
-
-        return sqlParts.length > 0 ? { sql: sqlParts.join(', '), params: params } : -1;
-    }
-
-    /**
-     * NEW SECURE VERSION: Build SQL INSERT with parameterized queries (MySQL)
-     * Returns {tableName, columns, placeholders, params}
-     */
-    _buildSQLInsertObjectParameterized(fields, modelEntity){
-        var $that = this;
-        var columnNames = [];
-        var params = [];
-
-        for (var column in modelEntity) {
-            if(column.indexOf("__") === -1 ){
-                var fieldColumn = fields[column];
-
-                if((fieldColumn !== undefined && fieldColumn !== null ) && typeof(fieldColumn) !== "object"){
-                    // 🔥 Apply toDatabase transformer before validation
-                    try { fieldColumn = FieldTransformer.toDatabase(fieldColumn, modelEntity[column], modelEntity.__name, column); }
-                    catch(transformError) { throw new Error(`INSERT failed: ${transformError.message}`); }
-
-                    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);
-                    params.push(fieldColumn);
-                }
-                else{
-                    switch(modelEntity[column].type){
-                        case "belongsTo":
-                            var fieldObject = tools.findTrackedObject(fields.__context.__trackedEntities, column);
-                            if(Object.keys(fieldObject).length > 0){
-                                var primaryKey = tools.getPrimaryKeyObject(fieldObject.__entity);
-                                fieldColumn = fieldObject[primaryKey];
-                                var actualColumn = modelEntity[column].foreignKey;
-                                columnNames.push(actualColumn);
-                                params.push(fieldColumn);
-                            }
-                        break;
-                    }
-                }
-            }
-        }
-
-        if(columnNames.length > 0){
-            var placeholders = params.map(() => '?').join(', ');
-            return { tableName: modelEntity.__name, columns: columnNames.join(', '), placeholders: placeholders, params: params };
-        } else {
-            return -1;
-        }
-    }
-
-    /**
-     * 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
-     * @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":
-            case "bool":
-                if (typeof value === 'boolean') return value;
-                if (value === 1 || value === '1' || value === 'true' || value === true) return true;
-                if (value === 0 || value === '0' || value === 'false' || value === false) return false;
-                throw new Error(`Invalid boolean value: ${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){
-        var $that = this;
-        var columns = null;
-        var values = null;
-        for (var column in modelEntity) {
-            // column1 = value1, column2 = value2, ...
-            if(column.indexOf("__") === -1 ){
-                // call the get method if avlable
-                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(fieldColumn, { entityName: modelEntity.__name, fieldName: column })}'`;
-                        break;
-                        case "time" :
-                            // Quote time values to prevent blank values from producing malformed SQL
-                            fieldColumn = `'${fieldColumn}'`;
-                        break;
-                    }
-
-                    var relationship = modelEntity[column].relationshipType
-                    if(relationship === "belongsTo"){
-                        column = modelEntity[column].foreignKey
-                    }
-
-
-                    // Use backtick-quoted identifiers for MySQL column names
-                    columns = columns === null ? `\`${column}\`,` : `${columns} \`${column}\`,`;
-                    values = values === null ? `${fieldColumn},` : `${values} ${fieldColumn},`;
-
-                }
-            }
-        }
-
-        return {tableName: modelEntity.__name, columns: columns.replace(/,\s*$/, ""), values: values.replace(/,\s*$/, "")};
-
-    }
-
-    // will add double single quotes to allow string to be saved.
-    _santizeSingleQuotes(value, context){
-        if (typeof value === 'string' || value instanceof String){
-            return value.replace(/'/g, "''");
-        }
-        else{
-            var details = context || {};
-            var entityName = details.entityName || 'UnknownEntity';
-            var fieldName = details.fieldName || 'UnknownField';
-            var valueType = (value === null) ? 'null' : (value === undefined ? 'undefined' : typeof value);
-            var preview;
-            try{ preview = (value === null || value === undefined) ? String(value) : JSON.stringify(value); }
-            catch(_){ preview = '[unserializable]'; }
-            if(preview && preview.length > 120){ preview = preview.substring(0, 120) + '…'; }
-            var message = `Field is not a string: entity=${entityName}, field=${fieldName}, type=${valueType}, value=${preview}`;
-            console.error(message);
-            throw new Error(message);
-        }
-    }
-
-    // converts any object into SQL parameter select string
-    _convertEntityToSelectParameterString(obj, entityName){
-        // todo: loop throgh object and append string with comma to 
-        var mainString = "";
-        const entries = Object.keys(obj);
-
-        for (const [name] of entries) {
-         mainString += `${mainString}, ${entityName}.${name}`;
-        }
-        return mainString;;
-    }
-
-    _execute(query){
-        if (process.env.LOG_SQL === 'true' || process.env.NODE_ENV !== 'production') {
-            console.debug("[SQL]", query);
-        }
-        try{
-            this.db.connect(this.db);
-            const res = this.db.query(query);
-            if(res === null){
-                const dbName = (this.db && this.db.config && this.db.config.database) ? this.db.config.database : '(unknown)';
-                if(this.db && this.db.lastErrorCode === 'ER_BAD_DB_ERROR'){
-                    console.error(`MySQL execute skipped: database '${dbName}' does not exist`);
-                }else{
-                    console.error('MySQL execute skipped: connection not defined');
-                }
-                return null;
-            }
-            return res;
-        }catch(err){
-            const code = err && err.code ? err.code : '';
-            if(code === 'ER_BAD_DB_ERROR' || code === 'ECONNREFUSED' || code === 'PROTOCOL_CONNECTION_LOST'){
-                const dbName = (this.db && this.db.config && this.db.config.database) ? this.db.config.database : '(unknown)';
-                if(code === 'ER_BAD_DB_ERROR'){
-                    console.error(`MySQL execute skipped: database '${dbName}' does not exist`);
-                } else {
-                    console.error('MySQL execute skipped: connection not defined');
-                }
-                return null;
-            }
-            console.error(err);
-            return null;
-        }
-    }
-
-     _run(query){
-        try{
-            if (process.env.LOG_SQL === 'true' || process.env.NODE_ENV !== 'production') {
-                console.debug("[SQL]", query);
-            }
-            this.db.connect(this.db);
-            const result = this.db.query(query);
-
-            return result;}
-        catch (error) {
-            console.error(error);
-            // Expected output: ReferenceError: nonExistentFunction is not defined
-            // (Note: the exact output may be browser-dependent)
-          }
-    }
-
-    /**
-     * NEW SECURE VERSION: Execute query with parameters
-     * Prevents SQL injection by using parameterized queries
-     */
-    _executeWithParams(query, params = []){
-        if (process.env.LOG_SQL === 'true' || process.env.NODE_ENV !== 'production') {
-            console.debug("[SQL]", query);
-            console.debug("[Params]", params);
-        }
-        try{
-            this.db.connect(this.db);
-            const res = this.db.query(query, params);
-            if(res === null){
-                const dbName = (this.db && this.db.config && this.db.config.database) ? this.db.config.database : '(unknown)';
-                if(this.db && this.db.lastErrorCode === 'ER_BAD_DB_ERROR'){
-                    console.error(`MySQL execute skipped: database '${dbName}' does not exist`);
-                }else{
-                    console.error('MySQL execute skipped: connection not defined');
-                }
-                return null;
-            }
-            return res;
-        }catch(err){
-            const code = err && err.code ? err.code : '';
-            if(code === 'ER_BAD_DB_ERROR' || code === 'ECONNREFUSED' || code === 'PROTOCOL_CONNECTION_LOST'){
-                const dbName = (this.db && this.db.config && this.db.config.database) ? this.db.config.database : '(unknown)';
-                if(code === 'ER_BAD_DB_ERROR'){
-                    console.error(`MySQL execute skipped: database '${dbName}' does not exist`);
-                } else {
-                    console.error('MySQL execute skipped: connection not defined');
-                }
-                return null;
-            }
-            console.error(err);
-            return null;
-        }
-    }
-
-    /**
-     * NEW SECURE VERSION: Run query with parameters
-     * Prevents SQL injection by using parameterized queries
-     */
-    _runWithParams(query, params = []){
-        try{
-            if (process.env.LOG_SQL === 'true' || process.env.NODE_ENV !== 'production') {
-                console.debug("[SQL]", query);
-                console.debug("[Params]", params);
-            }
-            this.db.connect(this.db);
-            const result = this.db.query(query, params);
-            return result;
-        }
-        catch (error) {
-            console.error(error);
-        }
-    }
-
-    setDB(db, type){
-       this.db = db;
-       this.dbType = type; // this will let us know which type of sqlengine to use.
-   }
-}
-
-module.exports = SQLLiteEngine;
-
-
-
-
-/***
- * 
- * 
- * 
- * const mysql = require('mysql2/promise');
-
-class MySQLClient {
-    constructor(config) {
-        this.config = config;
-        this.pool = mysql.createPool(config);
-    }
-
-    async query(sql, params = []) {
-        const connection = await this.pool.getConnection();
-        try {
-            const [results] = await connection.execute(sql, params);
-            return results;
-        } finally {
-            connection.release();
-        }
-    }
-
-    async close() {
-        await this.pool.end();
-    }
-}
-
-module.exports = MySQLClient;
-
- */