@reldens/storage 0.59.0 → 0.61.0

package/lib/prisma/prisma-driver.js

@@ -22,182 +22,244 @@ class PrismaDriver extends BaseDriver
             Logger.critical('Missing Prisma model on Prisma driver.');
             return false;
         }
-        if(!props.server){
-            Logger.critical('Missing Server Driver on Prisma driver.');
-            return false;
-        }
         this.prisma = props.prisma;
         this.model = props.model;
-        this.server = props.server;
         this.requiredFields = [];
+        this.optionalFields = [];
         this.fieldTypes = {};
+        this.fieldDefaults = {};
         this.idFieldType = 'String';
         this.referenceFields = {};
         this.relationMetadata = {};
-        this.initFieldMetadata();
-        this.initRelationMetadata();
+        this.foreignKeyMappings = {};
+        this.jsonFields = new Set();
+        this.initModelMetadata();
     }
 
-    initFieldMetadata()
+    initModelMetadata()
     {
-        try {
-            let dmmf = this.prisma._runtimeDataModel || Prisma.dmmf?.datamodel;
-            if(!dmmf){
-                return;
-            }
-            let modelName = this.tableName().toLowerCase();
-            let modelInfo = dmmf.models?.[modelName] || dmmf.models?.find(m => m.name.toLowerCase() === modelName);
-            if(!modelInfo){
-                return;
-            }
-            for(let field of modelInfo.fields){
-                if(field.isRequired && !field.hasDefaultValue && !field.isId){
-                    this.requiredFields.push(field.name);
-                }
-                this.fieldTypes[field.name] = field.type;
-                if(field.isId){
-                    this.idFieldType = field.type;
-                }
-                if(field.kind === 'scalar' && field.isList === false){
-                    let isNumericType = ('Int' === field.type || 'BigInt' === field.type || 'Float' === field.type || 'Decimal' === field.type);
-                    let isReferenceField = field.relationFromFields && 0 < field.relationFromFields.length;
-                    if(isNumericType || isReferenceField){
-                        this.referenceFields[field.name] = field.type;
-                    }
+        let dmmf = this.getDmmf();
+        if(!dmmf){
+            Logger.warning('Could not access Prisma DMMF metadata');
+            return;
+        }
+        let modelName = this.tableName().toLowerCase();
+        let modelInfo = dmmf.models?.[modelName] || dmmf.models?.find(m => m.name.toLowerCase() === modelName);
+        if(!modelInfo){
+            Logger.warning('Could not find model info for: '+modelName);
+            return;
+        }
+        for(let field of modelInfo.fields){
+            this.processFieldMetadata(field);
+        }
+        if(this.rawModel && this.rawModel.relationTypes){
+            for(let relationName of Object.keys(this.rawModel.relationTypes)){
+                if(sc.hasOwn(this.relationMetadata, relationName)){
+                    this.relationMetadata[relationName].type = this.rawModel.relationTypes[relationName];
                 }
             }
-        } catch(error) {
-            Logger.warning('Could not initialize field metadata: '+error.message);
         }
     }
 
-    initRelationMetadata()
+    getDmmf()
     {
         try {
-            let dmmf = this.prisma._runtimeDataModel || Prisma.dmmf?.datamodel;
-            if(!dmmf){
-                return;
-            }
-            let modelName = this.tableName().toLowerCase();
-            let modelInfo = dmmf.models?.[modelName] || dmmf.models?.find(m => m.name.toLowerCase() === modelName);
-            if(!modelInfo){
-                return;
-            }
-            for(let field of modelInfo.fields){
-                if('object' === field.kind){
-                    let relationType = 'many';
-                    if(!field.isList){
-                        relationType = 'one';
-                    }
-                    this.relationMetadata[field.name] = {
-                        type: relationType,
-                        model: field.type,
-                        isList: field.isList,
-                        isOptional: field.isOptional
-                    };
-                }
+            if(this.prisma._dmmf){
+                return this.prisma._dmmf.datamodel;
             }
-            if(this.rawModel && this.rawModel.relationTypes){
-                for(let relationName of Object.keys(this.rawModel.relationTypes)){
-                    if(sc.hasOwn(this.relationMetadata, relationName)){
-                        this.relationMetadata[relationName].type = this.rawModel.relationTypes[relationName];
-                    }
-                }
+            if(this.prisma._getDmmf && sc.isFunction(this.prisma._getDmmf)){
+                return this.prisma._getDmmf().datamodel;
+            }
+            if(this.prisma._runtimeDataModel){
+                return this.prisma._runtimeDataModel;
+            }
+            if(Prisma.dmmf && Prisma.dmmf.datamodel){
+                return Prisma.dmmf.datamodel;
             }
+            return null;
         } catch(error) {
-            Logger.warning('Could not initialize relation metadata: '+error.message);
+            Logger.warning('Failed to access DMMF: '+error.message);
+            return null;
         }
     }
 
-    castIdValue(id)
+    processFieldMetadata(field)
     {
-        if(null === id || undefined === id){
-            return id;
+        this.fieldTypes[field.name] = field.type;
+        if('Json' === field.type){
+            this.jsonFields.add(field.name);
         }
-        if('Int' === this.idFieldType || 'BigInt' === this.idFieldType){
-            let numericId = Number(id);
-            if(!isNaN(numericId)){
-                return numericId;
-            }
+        if(field.isId){
+            this.idFieldType = field.type;
         }
-        return String(id);
-    }
-
-    castNumericValue(value, fieldType)
-    {
-        if(null === value || undefined === value || '' === value){
-            return null;
+        if(field.hasDefaultValue){
+            this.fieldDefaults[field.name] = field.default;
         }
-        if('Int' === fieldType || 'BigInt' === fieldType){
-            let numericValue = Number(value);
-            if(!isNaN(numericValue)){
-                return Math.floor(numericValue);
+        if(field.isRequired && !field.hasDefaultValue && !field.isId && 'object' !== field.kind){
+            this.requiredFields.push(field.name);
+        }
+        if(field.isOptional || field.hasDefaultValue){
+            this.optionalFields.push(field.name);
+        }
+        if(field.kind === 'scalar' && field.isList === false){
+            let isNumericType = this.isNumericFieldType(field.type);
+            let isReferenceField = field.relationFromFields && 0 < field.relationFromFields.length;
+            if(isNumericType || isReferenceField){
+                this.referenceFields[field.name] = field.type;
             }
         }
-        if('Float' === fieldType || 'Decimal' === fieldType){
-            let numericValue = Number(value);
-            if(!isNaN(numericValue)){
-                return numericValue;
+        if('object' === field.kind){
+            let relationType = field.isList ? 'many' : 'one';
+            this.relationMetadata[field.name] = {
+                type: relationType,
+                model: field.type,
+                isList: field.isList,
+                isOptional: field.isOptional
+            };
+        }
+        if('object' === field.kind && sc.hasOwn(field, 'relationFromFields') && sc.isArray(field.relationFromFields)){
+            for(let foreignKeyField of field.relationFromFields){
+                this.foreignKeyMappings[foreignKeyField] = field.name;
             }
         }
-        return value;
     }
 
-    databaseName()
+    isNumericFieldType(fieldType)
     {
-        return this.config.database || '';
+        return ('Int' === fieldType || 'BigInt' === fieldType || 'Float' === fieldType || 'Decimal' === fieldType);
     }
 
-    id()
+    isBooleanFieldType(fieldType)
     {
-        return this.name || '';
+        return 'Boolean' === fieldType;
     }
 
-    name()
+    isDateTimeFieldType(fieldType)
     {
-        return this.rawName || '';
+        return 'DateTime' === fieldType || 'Date' === fieldType;
     }
 
-    tableName()
+    isJsonFieldType(fieldType)
     {
-        return this.model.name || '';
+        return 'Json' === fieldType;
     }
 
-    property(propertyName)
+    isJsonFieldByName(fieldName)
     {
-        return this.rawModel[propertyName] || null;
+        if(this.jsonFields.has(fieldName)){
+            return true;
+        }
+        if(!this.rawModel || !this.rawModel.properties){
+            return false;
+        }
+        return 'json' === sc.get(this.rawModel.properties[fieldName], 'dbType', '');
     }
 
-    prepareData(params)
+    isStringFieldType(fieldType)
+    {
+        return 'String' === fieldType;
+    }
+
+    castValue(value, fieldType, fieldName = null)
     {
-        let data = {...params};
-        for(let key of Object.keys(data)){
-            if('status' === key && 'number' === typeof data[key]){
-                data[key] = String(data[key]);
+        if('id' === fieldName){
+            return this.castToIdType(value);
+        }
+        if(this.isNullOrEmpty(value)){
+            if(sc.hasOwn(this.fieldDefaults, fieldName)){
+                return undefined;
             }
-            if(this.isDateTimeField(key)){
-                data[key] = this.convertToDate(data[key], key);
-                continue;
+            if(-1 !== this.optionalFields.indexOf(fieldName)){
+                return null;
             }
-            if(sc.hasOwn(this.referenceFields, key)){
-                data[key] = this.castNumericValue(data[key], this.referenceFields[key]);
+            if(-1 !== this.requiredFields.indexOf(fieldName)){
+                Logger.warning('Required field '+fieldName+' cannot be null or empty');
+                return undefined;
             }
+            return null;
         }
-        return data;
+        if(this.isJsonFieldByName(fieldName)){
+            return this.castToJsonType(value);
+        }
+        if(this.isNumericFieldType(fieldType)){
+            return this.castToNumericType(value, fieldType);
+        }
+        if(this.isBooleanFieldType(fieldType)){
+            return this.castToBooleanType(value);
+        }
+        if(this.isDateTimeFieldType(fieldType)){
+            return this.castToDateType(value);
+        }
+        if(this.isStringFieldType(fieldType)){
+            return this.castToStringType(value);
+        }
+        return value;
+    }
+
+    isNullOrEmpty(value)
+    {
+        return null === value || undefined === value || '' === value;
+    }
+
+    castToIdType(value)
+    {
+        if(this.isNullOrEmpty(value)){
+            return value;
+        }
+        if(this.isNumericFieldType(this.idFieldType)){
+            let numeric = Number(value);
+            if(!isNaN(numeric)){
+                return ('Int' === this.idFieldType || 'BigInt' === this.idFieldType) ? Math.floor(numeric) : numeric;
+            }
+        }
+        return String(value);
     }
 
-    isDateTimeField(fieldName)
+    castToNumericType(value, fieldType)
     {
-        let fieldType = this.fieldTypes[fieldName];
-        return fieldType === 'DateTime' || fieldType === 'Date';
+        if(this.isNullOrEmpty(value)){
+            return null;
+        }
+        let numericValue = Number(value);
+        if(isNaN(numericValue)){
+            Logger.warning('Cannot convert value to numeric: '+value);
+            return null;
+        }
+        if('Int' === fieldType || 'BigInt' === fieldType){
+            return Math.floor(numericValue);
+        }
+        return numericValue;
+    }
+
+    castToBooleanType(value)
+    {
+        if(this.isNullOrEmpty(value)){
+            return null;
+        }
+        if('boolean' === typeof value){
+            return value;
+        }
+        if('number' === typeof value){
+            return 0 !== value;
+        }
+        if('string' === typeof value){
+            let lowerValue = value.toLowerCase();
+            if('true' === lowerValue || '1' === lowerValue || 'yes' === lowerValue){
+                return true;
+            }
+            if('false' === lowerValue || '0' === lowerValue || 'no' === lowerValue){
+                return false;
+            }
+        }
+        return Boolean(value);
     }
 
-    convertToDate(dateValue, fieldName)
+    castToDateType(dateValue)
     {
         if(dateValue instanceof Date){
             return dateValue;
         }
-        if(!dateValue || '' === dateValue){
+        if(this.isNullOrEmpty(dateValue)){
             return null;
         }
         let dateString = String(dateValue);
@@ -208,11 +270,132 @@ class PrismaDriver extends BaseDriver
             return new Date(dateString + 'T00:00:00Z');
         }
         try {
-            return new Date(dateString);
+            let parsedDate = new Date(dateString);
+            if(isNaN(parsedDate.getTime())){
+                Logger.warning('Invalid date value: '+dateString);
+                return null;
+            }
+            return parsedDate;
         } catch(error) {
             Logger.warning('Failed to convert date value: '+dateString);
-            return dateValue;
+            return null;
+        }
+    }
+
+    castToJsonType(value)
+    {
+        if(this.isNullOrEmpty(value)){
+            return Prisma.DbNull;
+        }
+        if('object' === typeof value){
+            return value;
+        }
+        if('string' === typeof value){
+            if(value.startsWith('%') && value.endsWith('%')){
+                return value;
+            }
+            try {
+                return JSON.parse(value);
+            } catch(error) {
+                return value;
+            }
+        }
+        return value;
+    }
+
+    castToStringType(value)
+    {
+        if(null === value || undefined === value){
+            return null;
+        }
+        if('string' === typeof value){
+            if('null' === value){
+                return null;
+            }
+            return value;
+        }
+        return String(value);
+    }
+
+    databaseName()
+    {
+        return this.config.database || '';
+    }
+
+    id()
+    {
+        return this.name || '';
+    }
+
+    name()
+    {
+        return this.rawName || '';
+    }
+
+    tableName()
+    {
+        return this.model.$name || this.model.name || '';
+    }
+
+    property(propertyName)
+    {
+        return this.rawModel[propertyName] || null;
+    }
+
+    prepareData(params)
+    {
+        let data = {};
+        for(let key of Object.keys(params)){
+            let fieldType = this.fieldTypes[key];
+            if(!fieldType){
+                data[key] = params[key];
+                continue;
+            }
+            let castedValue = this.castValue(params[key], fieldType, key);
+            if(undefined !== castedValue){
+                data[key] = castedValue;
+            }
         }
+        return data;
+    }
+
+    prepareDataWithRelations(params, isCreate = false)
+    {
+        let data = {};
+        let relations = {};
+        for(let key of Object.keys(params)){
+            if(sc.hasOwn(this.foreignKeyMappings, key)){
+                let relationName = this.foreignKeyMappings[key];
+                let value = params[key];
+                if(!this.isNullOrEmpty(value)){
+                    relations[relationName] = {
+                        connect: {id: this.castToIdType(value)}
+                    };
+                    continue;
+                }
+                if(!isCreate){
+                    relations[relationName] = {
+                        disconnect: true
+                    };
+                }
+                continue;
+            }
+            let fieldType = this.fieldTypes[key];
+            if(!fieldType){
+                if(!this.isNullOrEmpty(params[key])){
+                    data[key] = params[key];
+                }
+                continue;
+            }
+            let castedValue = this.castValue(params[key], fieldType, key);
+            if(undefined !== castedValue){
+                if(this.isJsonFieldType(fieldType) && null === castedValue){
+                    continue;
+                }
+                data[key] = castedValue;
+            }
+        }
+        return {...data, ...relations};
     }
 
     ensureRequiredFields(data)
@@ -237,20 +420,12 @@ class PrismaDriver extends BaseDriver
         let processedFilters = {};
         for(let key of Object.keys(filters)){
             let value = filters[key];
+            if('OR' === key && sc.isArray(value)){
+                processedFilters.OR = value.map(condition => this.processFilters(condition));
+                continue;
+            }
             if(sc.hasOwn(value, 'operator') && sc.hasOwn(value, 'value')){
-                let operatorValue = value.value;
-                if('id' === key && sc.isArray(operatorValue)){
-                    operatorValue = operatorValue.map(id => this.castIdValue(id));
-                }
-                if('id' === key && !sc.isArray(operatorValue)){
-                    operatorValue = this.castIdValue(operatorValue);
-                }
-                if(sc.hasOwn(this.referenceFields, key) && sc.isArray(operatorValue)){
-                    operatorValue = operatorValue.map(val => this.castNumericValue(val, this.referenceFields[key]));
-                }
-                if(sc.hasOwn(this.referenceFields, key) && !sc.isArray(operatorValue)){
-                    operatorValue = this.castNumericValue(operatorValue, this.referenceFields[key]);
-                }
+                let operatorValue = this.processFilterValue(value.value, key);
                 processedFilters[key] = this.applyOperator(operatorValue, value.operator, key);
                 continue;
             }
@@ -258,25 +433,32 @@ class PrismaDriver extends BaseDriver
                 processedFilters[key] = this.processFilters(value);
                 continue;
             }
-            if('id' === key && sc.isArray(value)){
-                processedFilters[key] = value.map(id => this.castIdValue(id));
-                continue;
-            }
+            processedFilters[key] = this.processFilterValue(value, key);
+        }
+        return processedFilters;
+    }
+
+    processFilterValue(value, key)
+    {
+        if(sc.isArray(value)){
             if('id' === key){
-                processedFilters[key] = this.castIdValue(value);
-                continue;
+                return value.map(id => this.castToIdType(id));
             }
-            if(sc.hasOwn(this.referenceFields, key) && sc.isArray(value)){
-                processedFilters[key] = value.map(val => this.castNumericValue(val, this.referenceFields[key]));
-                continue;
+            let fieldType = this.fieldTypes[key];
+            if(fieldType){
+                return value.map(val => this.castValue(val, fieldType, key)).filter(val => undefined !== val);
             }
-            if(sc.hasOwn(this.referenceFields, key)){
-                processedFilters[key] = this.castNumericValue(value, this.referenceFields[key]);
-                continue;
-            }
-            processedFilters[key] = value;
+            return value;
         }
-        return processedFilters;
+        if('id' === key){
+            return this.castToIdType(value);
+        }
+        let fieldType = this.fieldTypes[key];
+        if(fieldType){
+            let castedValue = this.castValue(value, fieldType, key);
+            return undefined !== castedValue ? castedValue : value;
+        }
+        return value;
     }
 
     transformRelationResults(result, includeConfig)
@@ -318,9 +500,9 @@ class PrismaDriver extends BaseDriver
 
     async create(params)
     {
+        let preparedData = this.prepareDataWithRelations(params, true);
+        this.ensureRequiredFields(preparedData);
         try {
-            let preparedData = this.prepareData(params);
-            this.ensureRequiredFields(preparedData);
             return await this.model.create({
                 data: preparedData
             });
@@ -332,27 +514,27 @@ class PrismaDriver extends BaseDriver
 
     async createWithRelations(params, relations)
     {
-        try {
-            let preparedData = this.prepareData(params);
-            this.ensureRequiredFields(preparedData);
-            let createData = {data: preparedData};
-            if(sc.isArray(relations) && 0 < relations.length){
-                for(let relation of relations){
-                    if(!sc.hasOwn(params, relation)){
-                        continue;
-                    }
-                    let relationData = params[relation];
-                    if(sc.isArray(relationData)){
-                        createData.data[relation] = {
-                            connect: relationData.map(item => ({id: this.castIdValue(item.id)}))
-                        };
-                        continue;
-                    }
+        let preparedData = this.prepareData(params);
+        this.ensureRequiredFields(preparedData);
+        let createData = {data: preparedData};
+        if(sc.isArray(relations) && 0 < relations.length){
+            for(let relation of relations){
+                if(!sc.hasOwn(params, relation)){
+                    continue;
+                }
+                let relationData = params[relation];
+                if(sc.isArray(relationData)){
                     createData.data[relation] = {
-                        connect: {id: this.castIdValue(relationData.id)}
+                        connect: relationData.map(item => ({id: this.castToIdType(item.id)}))
                     };
+                    continue;
                 }
+                createData.data[relation] = {
+                    connect: {id: this.castToIdType(relationData.id)}
+                };
             }
+        }
+        try {
             return await this.model.create(createData);
         } catch(error) {
             Logger.error('Create with relations error: '+error.message);
@@ -362,9 +544,9 @@ class PrismaDriver extends BaseDriver
 
     async update(filters, updatePatch)
     {
+        let preparedData = this.prepareDataWithRelations(updatePatch);
+        let processedFilters = this.processFilters(filters);
         try {
-            let preparedData = this.prepareData(updatePatch);
-            let processedFilters = this.processFilters(filters);
             return await this.model.updateMany({
                 where: processedFilters,
                 data: preparedData
@@ -378,8 +560,8 @@ class PrismaDriver extends BaseDriver
     async updateBy(field, fieldValue, updatePatch, operator = null)
     {
         let filter = this.createSingleFilter(field, fieldValue, operator);
+        let preparedData = this.prepareDataWithRelations(updatePatch);
         try {
-            let preparedData = this.prepareData(updatePatch);
             return await this.model.updateMany({
                 where: filter,
                 data: preparedData
@@ -392,13 +574,13 @@ class PrismaDriver extends BaseDriver
 
     async updateById(id, params)
     {
+        let castedId = this.castToIdType(id);
+        let found = await this.loadById(castedId);
+        if(!found){
+            return false;
+        }
+        let preparedData = this.prepareDataWithRelations(params);
         try {
-            let castedId = this.castIdValue(id);
-            let found = await this.loadById(castedId);
-            if(!found){
-                return false;
-            }
-            let preparedData = this.prepareData(params);
             return await this.model.update({
                 where: {id: castedId},
                 data: preparedData
@@ -411,41 +593,46 @@ class PrismaDriver extends BaseDriver
 
     async upsert(params, filters)
     {
-        try {
-            let preparedData = this.prepareData(params);
-            let existing = false;
-            if(params.id){
-                let castedId = this.castIdValue(params.id);
-                existing = await this.loadById(castedId);
-                if(existing){
-                    let patch = Object.assign({}, preparedData);
-                    delete patch.id;
+        let preparedData = this.prepareDataWithRelations(params);
+        let existing = false;
+        if(params.id){
+            let castedId = this.castToIdType(params.id);
+            existing = await this.loadById(castedId);
+            if(existing){
+                let patch = Object.assign({}, preparedData);
+                delete patch.id;
+                try {
                     return await this.model.update({
                         where: {id: castedId},
                         data: patch
                     });
+                } catch(error) {
+                    Logger.error('Upsert update error: '+error.message);
+                    return false;
                 }
             }
-            if(filters){
-                let existing = await this.loadOne(filters);
-                if(existing){
+        }
+        if(filters){
+            let existing = await this.loadOne(filters);
+            if(existing){
+                try {
                     return await this.model.update({
-                        where: {id: this.castIdValue(existing.id)},
+                        where: {id: this.castToIdType(existing.id)},
                         data: preparedData
                     });
+                } catch(error) {
+                    Logger.error('Upsert update by filter error: '+error.message);
+                    return false;
                 }
             }
-            return await this.create(preparedData);
-        } catch(error) {
-            Logger.error('Upsert error: '+error.message);
-            return false;
         }
+        return await this.create(preparedData);
     }
 
     async delete(filters = {})
     {
+        let processedFilters = this.processFilters(filters);
         try {
-            let processedFilters = this.processFilters(filters);
             return await this.model.deleteMany({
                 where: processedFilters
             });
@@ -457,12 +644,12 @@ class PrismaDriver extends BaseDriver
 
     async deleteById(id)
     {
+        let castedId = this.castToIdType(id);
+        let found = await this.loadById(castedId);
+        if(!found){
+            return false;
+        }
         try {
-            let castedId = this.castIdValue(id);
-            let found = await this.loadById(castedId);
-            if(!found){
-                return false;
-            }
             return await this.model.delete({
                 where: {id: castedId}
             });
@@ -474,8 +661,8 @@ class PrismaDriver extends BaseDriver
 
     async count(filters)
     {
+        let processedFilters = this.processFilters(filters);
         try {
-            let processedFilters = this.processFilters(filters);
             return await this.model.count({
                 where: processedFilters
             });
@@ -487,14 +674,14 @@ class PrismaDriver extends BaseDriver
 
     async countWithRelations(filters, relations)
     {
+        let processedFilters = this.processFilters(filters);
+        let query = {
+            where: processedFilters
+        };
+        if(sc.isArray(relations) && 0 < relations.length){
+            query.include = this.buildIncludeObject(relations);
+        }
         try {
-            let processedFilters = this.processFilters(filters);
-            let query = {
-                where: processedFilters
-            };
-            if(sc.isArray(relations) && 0 < relations.length){
-                query.include = this.buildIncludeObject(relations);
-            }
             return await this.model.count(query);
         } catch(error) {
             Logger.error('Count with relations error: '+error.message);
@@ -514,13 +701,13 @@ class PrismaDriver extends BaseDriver
 
     async loadAllWithRelations(relations)
     {
+        let query = this.buildQueryOptions();
+        let includeConfig = {};
+        if(sc.isArray(relations) && 0 < relations.length){
+            includeConfig = this.buildIncludeObject(relations);
+            query.include = includeConfig;
+        }
         try {
-            let query = this.buildQueryOptions();
-            let includeConfig = {};
-            if(sc.isArray(relations) && 0 < relations.length){
-                includeConfig = this.buildIncludeObject(relations);
-                query.include = includeConfig;
-            }
             let results = await this.model.findMany(query);
             return this.transformRelationResults(results, includeConfig);
         } catch(error) {
@@ -531,10 +718,10 @@ class PrismaDriver extends BaseDriver
 
     async load(filters)
     {
+        let processedFilters = this.processFilters(filters);
+        let query = this.buildQueryOptions();
+        query.where = processedFilters;
         try {
-            let processedFilters = this.processFilters(filters);
-            let query = this.buildQueryOptions();
-            query.where = processedFilters;
             return await this.model.findMany(query);
         } catch(error) {
             Logger.error('Load error: '+error.message);
@@ -544,15 +731,15 @@ class PrismaDriver extends BaseDriver
 
     async loadWithRelations(filters, relations)
     {
+        let processedFilters = this.processFilters(filters);
+        let query = this.buildQueryOptions();
+        query.where = processedFilters;
+        let includeConfig = {};
+        if(sc.isArray(relations) && 0 < relations.length){
+            includeConfig = this.buildIncludeObject(relations);
+            query.include = includeConfig;
+        }
         try {
-            let processedFilters = this.processFilters(filters);
-            let query = this.buildQueryOptions();
-            query.where = processedFilters;
-            let includeConfig = {};
-            if(sc.isArray(relations) && 0 < relations.length){
-                includeConfig = this.buildIncludeObject(relations);
-                query.include = includeConfig;
-            }
             let results = await this.model.findMany(query);
             return this.transformRelationResults(results, includeConfig);
         } catch(error) {
@@ -563,10 +750,10 @@ class PrismaDriver extends BaseDriver
 
     async loadBy(field, fieldValue, operator = null)
     {
+        let filter = this.createSingleFilter(field, fieldValue, operator);
+        let query = this.buildQueryOptions();
+        query.where = filter;
         try {
-            let filter = this.createSingleFilter(field, fieldValue, operator);
-            let query = this.buildQueryOptions();
-            query.where = filter;
             return await this.model.findMany(query);
         } catch(error) {
             Logger.error('Load by error: '+error.message);
@@ -576,15 +763,15 @@ class PrismaDriver extends BaseDriver
 
     async loadByWithRelations(field, fieldValue, relations, operator = null)
     {
+        let filter = this.createSingleFilter(field, fieldValue, operator);
+        let query = this.buildQueryOptions();
+        query.where = filter;
+        let includeConfig = {};
+        if(sc.isArray(relations) && 0 < relations.length){
+            includeConfig = this.buildIncludeObject(relations);
+            query.include = includeConfig;
+        }
         try {
-            let filter = this.createSingleFilter(field, fieldValue, operator);
-            let query = this.buildQueryOptions();
-            query.where = filter;
-            let includeConfig = {};
-            if(sc.isArray(relations) && 0 < relations.length){
-                includeConfig = this.buildIncludeObject(relations);
-                query.include = includeConfig;
-            }
             let results = await this.model.findMany(query);
             return this.transformRelationResults(results, includeConfig);
         } catch(error) {
@@ -595,8 +782,8 @@ class PrismaDriver extends BaseDriver
 
     async loadById(id)
     {
+        let castedId = this.castToIdType(id);
         try {
-            let castedId = this.castIdValue(id);
             return await this.model.findUnique({
                 where: {id: castedId}
             });
@@ -608,16 +795,16 @@ class PrismaDriver extends BaseDriver
 
     async loadByIdWithRelations(id, relations)
     {
+        let castedId = this.castToIdType(id);
+        let query = {
+            where: {id: castedId}
+        };
+        let includeConfig = {};
+        if(sc.isArray(relations) && 0 < relations.length){
+            includeConfig = this.buildIncludeObject(relations);
+            query.include = includeConfig;
+        }
         try {
-            let castedId = this.castIdValue(id);
-            let query = {
-                where: {id: castedId}
-            };
-            let includeConfig = {};
-            if(sc.isArray(relations) && 0 < relations.length){
-                includeConfig = this.buildIncludeObject(relations);
-                query.include = includeConfig;
-            }
             let result = await this.model.findUnique(query);
             return this.transformRelationResults(result, includeConfig);
         } catch(error) {
@@ -628,8 +815,8 @@ class PrismaDriver extends BaseDriver
 
     async loadByIds(ids)
     {
+        let castedIds = ids.map(id => this.castToIdType(id));
         try {
-            let castedIds = ids.map(id => this.castIdValue(id));
             return await this.model.findMany({
                 where: {
                     id: {in: castedIds}
@@ -643,10 +830,10 @@ class PrismaDriver extends BaseDriver
 
     async loadOne(filters)
     {
+        let processedFilters = this.processFilters(filters);
+        let query = this.buildQueryOptions(false);
+        query.where = processedFilters;
         try {
-            let processedFilters = this.processFilters(filters);
-            let query = this.buildQueryOptions(false);
-            query.where = processedFilters;
             return await this.model.findFirst(query);
         } catch(error) {
             Logger.error('Load one error: '+error.message);
@@ -656,15 +843,15 @@ class PrismaDriver extends BaseDriver
 
     async loadOneWithRelations(filters, relations)
     {
+        let processedFilters = this.processFilters(filters);
+        let query = this.buildQueryOptions(false);
+        query.where = processedFilters;
+        let includeConfig = {};
+        if(sc.isArray(relations) && 0 < relations.length){
+            includeConfig = this.buildIncludeObject(relations);
+            query.include = includeConfig;
+        }
         try {
-            let processedFilters = this.processFilters(filters);
-            let query = this.buildQueryOptions(false);
-            query.where = processedFilters;
-            let includeConfig = {};
-            if(sc.isArray(relations) && 0 < relations.length){
-                includeConfig = this.buildIncludeObject(relations);
-                query.include = includeConfig;
-            }
             let result = await this.model.findFirst(query);
             return this.transformRelationResults(result, includeConfig);
         } catch(error) {
@@ -675,10 +862,10 @@ class PrismaDriver extends BaseDriver
 
     async loadOneBy(field, fieldValue, operator = null)
     {
+        let filter = this.createSingleFilter(field, fieldValue, operator);
+        let query = this.buildQueryOptions(false);
+        query.where = filter;
         try {
-            let filter = this.createSingleFilter(field, fieldValue, operator);
-            let query = this.buildQueryOptions(false);
-            query.where = filter;
             return await this.model.findFirst(query);
         } catch(error) {
             Logger.error('Load one by error: '+error.message);
@@ -688,15 +875,15 @@ class PrismaDriver extends BaseDriver
 
     async loadOneByWithRelations(field, fieldValue, relations, operator = null)
     {
+        let filter = this.createSingleFilter(field, fieldValue, operator);
+        let query = this.buildQueryOptions(false);
+        query.where = filter;
+        let includeConfig = {};
+        if(sc.isArray(relations) && 0 < relations.length){
+            includeConfig = this.buildIncludeObject(relations);
+            query.include = includeConfig;
+        }
         try {
-            let filter = this.createSingleFilter(field, fieldValue, operator);
-            let query = this.buildQueryOptions(false);
-            query.where = filter;
-            let includeConfig = {};
-            if(sc.isArray(relations) && 0 < relations.length){
-                includeConfig = this.buildIncludeObject(relations);
-                query.include = includeConfig;
-            }
             let result = await this.model.findFirst(query);
             return this.transformRelationResults(result, includeConfig);
         } catch(error) {
@@ -731,23 +918,21 @@ class PrismaDriver extends BaseDriver
     createSingleFilter(field, fieldValue, operator = null)
     {
         let filter = {};
-        let processedValue = fieldValue;
-        if(sc.hasOwn(this.referenceFields, field)){
-            processedValue = this.castNumericValue(fieldValue, this.referenceFields[field]);
-        }
-        if('id' === field){
-            processedValue = this.castIdValue(fieldValue);
-        }
+        let processedValue = this.processFilterValue(fieldValue, field);
         if(null === operator){
             filter[field] = processedValue;
             return filter;
         }
-        filter[field] = this.applyOperator(processedValue, operator, field);
-        return filter;
+        filter[field] = {operator, value: processedValue};
+        return this.processFilters(filter);
     }
 
     applyOperator(value, operator, fieldName = null)
     {
+        let upperOperator = operator ? operator.toUpperCase() : '';
+        if('LIKE' === upperOperator){
+            return this.handleLikeOperator(value, fieldName);
+        }
         let operatorsMap = {
             '=': value,
             '!=': {not: value},
@@ -755,22 +940,32 @@ class PrismaDriver extends BaseDriver
             '>=': {gte: value},
             '<': {lt: value},
             '<=': {lte: value},
-            'LIKE': this.handleLikeOperator(value, fieldName),
             'IN': {in: value},
             'NOT IN': {notIn: value}
         };
-        return operatorsMap[operator] || value;
+        return operatorsMap[upperOperator] || value;
     }
 
     handleLikeOperator(value, fieldName)
     {
-        if('id' === fieldName || (this.referenceFields && sc.hasOwn(this.referenceFields, fieldName))){
-            let numericValue = Number(value.replace(/%/g, ''));
+        let cleanValue = String(value).replace(/%/g, '');
+        if(this.isJsonFieldByName(fieldName) || this.isJsonField(fieldName)){
+            return this.handleJsonTextSearch(cleanValue);
+        }
+        if('id' === fieldName || sc.hasOwn(this.referenceFields, fieldName)){
+            let numericValue = Number(cleanValue);
             if(!isNaN(numericValue)){
                 return numericValue;
             }
         }
-        return {contains: value};
+        return {contains: cleanValue};
+    }
+
+    handleJsonTextSearch(searchValue)
+    {
+        return {
+            string_contains: searchValue
+        };
     }
 
     buildIncludeObject(relations)