@reldens/storage 0.81.0 → 0.83.0

package/lib/prisma/prisma-driver.js

@@ -8,6 +8,8 @@ const { BaseDriver } = require('../base-driver');
 const { PrismaTypeCaster } = require('./prisma-type-caster');
 const { PrismaMetadataLoader } = require('./prisma-metadata-loader');
 const { PrismaRelationResolver } = require('./prisma-relation-resolver');
+const { PrismaFilterProcessor } = require('./prisma-filter-processor');
+const { PrismaQueryBuilder } = require('./prisma-query-builder');
 const { Logger, sc } = require('@reldens/utils');
 
 class PrismaDriver extends BaseDriver
@@ -26,6 +28,7 @@ class PrismaDriver extends BaseDriver
         }
         this.prisma = props.prisma;
         this.model = props.model;
+        this.allRelationMappings = sc.get(props, 'allRelationMappings', {});
         this.initHelpers();
         this.initModelMetadata();
     }
@@ -47,9 +50,19 @@ class PrismaDriver extends BaseDriver
         });
         this.relationResolver = new PrismaRelationResolver({
             relationMetadata: {},
-            relationAliases: {},
-            metadataLoader: this.metadataLoader
+            metadataLoader: this.metadataLoader,
+            allRelationMappings: this.allRelationMappings,
+            foreignKeyMappings: {},
+            foreignKeyTargetFields: {},
+            typeCaster: this.typeCaster
         });
+        this.filterProcessor = new PrismaFilterProcessor({
+            typeCaster: this.typeCaster,
+            fieldTypes: {},
+            referenceFields: {},
+            jsonFields: new Set()
+        });
+        this.queryBuilder = new PrismaQueryBuilder();
     }
 
     initModelMetadata()
@@ -63,9 +76,11 @@ class PrismaDriver extends BaseDriver
         this.fieldTypes = metadata.fieldTypes;
         this.fieldDefaults = metadata.fieldDefaults;
         this.idFieldType = metadata.idFieldType;
+        this.idFieldName = sc.get(metadata, 'idFieldName', 'id');
         this.referenceFields = metadata.referenceFields;
         this.relationMetadata = metadata.relationMetadata;
         this.foreignKeyMappings = metadata.foreignKeyMappings;
+        this.foreignKeyTargetFields = sc.get(metadata, 'foreignKeyTargetFields', {});
         this.jsonFields = metadata.jsonFields;
         this.typeCaster.updateMetadata({
             idFieldType: this.idFieldType,
@@ -76,9 +91,17 @@ class PrismaDriver extends BaseDriver
             optionalFields: this.optionalFields
         });
         this.relationResolver.updateMetadata({
-            relationMetadata: this.relationMetadata
+            relationMetadata: this.relationMetadata,
+            foreignKeyMappings: this.foreignKeyMappings,
+            foreignKeyTargetFields: this.foreignKeyTargetFields
+        });
+        this.filterProcessor.updateMetadata({
+            fieldTypes: this.fieldTypes,
+            referenceFields: this.referenceFields,
+            jsonFields: this.jsonFields
         });
-        this.relationAliases = this.relationResolver.buildRelationAliases(this.tableName());
+        let currentModelMappings = sc.get(this.allRelationMappings, this.tableName(), {});
+        this.relationResolver.setCurrentModelMappings(currentModelMappings);
     }
 
     databaseName()
@@ -111,183 +134,101 @@ class PrismaDriver extends BaseDriver
         return this.relationResolver.getAllRelations();
     }
 
-    prepareData(params)
+    getQueryOptions()
     {
-        let data = {};
-        for(let key of Object.keys(params)){
-            let fieldType = this.fieldTypes[key];
-            if(!fieldType){
-                data[key] = params[key];
-                continue;
-            }
-            let castedValue = this.typeCaster.castValue(params[key], fieldType, key);
-            if(undefined !== castedValue){
-                data[key] = castedValue;
-            }
+        return {
+            select: this.select,
+            limit: this.limit,
+            offset: this.offset,
+            sortBy: this.sortBy,
+            sortDirection: this.sortDirection
+        };
+    }
+
+    prepareData(params, options = {})
+    {
+        let skipObjects = sc.get(options, 'skipObjects', false);
+        let convertRelations = sc.get(options, 'convertRelations', false);
+        let isCreate = sc.get(options, 'isCreate', false);
+        if(convertRelations){
+            let converted = this.relationResolver.convertForeignKeysToRelations(params, isCreate);
+            return this.castDataFields(converted, skipObjects, isCreate);
         }
-        return data;
+        return this.castDataFields(params, skipObjects, isCreate);
     }
 
-    prepareDataWithRelations(params, isCreate = false)
+    castDataFields(params, skipObjects = false, 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.typeCaster.isNullOrEmpty(value)){
-                    relations[relationName] = {
-                        connect: {id: this.typeCaster.castToIdType(value)}
-                    };
-                    continue;
-                }
-                if(!isCreate){
-                    relations[relationName] = {
-                        disconnect: true
-                    };
-                }
+            let value = params[key];
+            if(skipObjects && sc.isObject(value) && !sc.isArray(value)){
+                continue;
+            }
+            if(isCreate && key === this.idFieldName && this.typeCaster.isNullOrEmpty(value)){
                 continue;
             }
             let fieldType = this.fieldTypes[key];
             if(!fieldType){
-                if(!this.typeCaster.isNullOrEmpty(params[key])){
-                    data[key] = params[key];
+                if(!skipObjects && !this.typeCaster.isNullOrEmpty(value)){
+                    data[key] = value;
                 }
                 continue;
             }
-            let castedValue = this.typeCaster.castValue(params[key], fieldType, key);
-            if(undefined !== castedValue){
-                if(this.typeCaster.isJsonFieldType(fieldType) && null === castedValue){
+            let castedValue = this.typeCaster.castValue(value, fieldType, key);
+            if(this.typeCaster.isValidCastedValue(castedValue)){
+                if(this.typeCaster.isJsonFieldType(fieldType) && null === castedValue && !skipObjects){
                     continue;
                 }
                 data[key] = castedValue;
             }
         }
-        return {...data, ...relations};
+        return data;
     }
 
     ensureRequiredFields(data)
     {
         let missingFields = [];
         for(let field of this.requiredFields){
-            if(!sc.hasOwn(data, field)){
-                missingFields.push(field);
-            }
-        }
-        if(0 < missingFields.length){
-            Logger.warning('Missing required fields for '+this.tableName()+': '+missingFields.join(', '));
-        }
-        return data;
-    }
-
-    processFilters(filters)
-    {
-        if(!sc.isObject(filters)){
-            return filters;
-        }
-        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));
+            if(sc.hasOwn(data, field)){
                 continue;
             }
-            if(sc.hasOwn(value, 'operator') && sc.hasOwn(value, 'value')){
-                let operatorValue = this.processFilterValue(value.value, key);
-                processedFilters[key] = this.applyOperator(operatorValue, value.operator, key);
-                continue;
+            if(sc.hasOwn(this.foreignKeyMappings, field)){
+                let relationName = this.foreignKeyMappings[field];
+                if(sc.hasOwn(data, relationName)){
+                    continue;
+                }
             }
-            if(sc.isObject(value) && !sc.isArray(value)){
-                processedFilters[key] = this.processFilters(value);
+            if(sc.hasOwn(this.fieldDefaults, field)){
                 continue;
             }
-            processedFilters[key] = this.processFilterValue(value, key);
-        }
-        return processedFilters;
-    }
-
-    processFilterValue(value, key)
-    {
-        if(sc.isArray(value)){
-            if('id' === key){
-                return value.map(id => this.typeCaster.castToIdType(id)).filter(id => null !== id);
-            }
-            let fieldType = this.fieldTypes[key];
-            if(fieldType){
-                return value.map(val => this.typeCaster.castValue(val, fieldType, key)).filter(val => undefined !== val);
-            }
-            return value;
-        }
-        if('id' === key){
-            return this.typeCaster.castToIdType(value);
+            missingFields.push(field);
         }
-        let fieldType = this.fieldTypes[key];
-        if(fieldType){
-            let castedValue = this.typeCaster.castValue(value, fieldType, key);
-            return undefined !== castedValue ? castedValue : value;
-        }
-        return value;
-    }
-
-    applyOperator(value, operator, fieldName = null)
-    {
-        let upperOperator = operator ? operator.toUpperCase() : '';
-        if('LIKE' === upperOperator){
-            return this.handleLikeOperator(value, fieldName);
+        if(0 < missingFields.length){
+            Logger.warning('Missing required fields for '+this.tableName()+': '+missingFields.join(', '));
         }
-        let operatorsMap = {
-            '=': value,
-            '!=': {not: value},
-            '>': {gt: value},
-            '>=': {gte: value},
-            '<': {lt: value},
-            '<=': {lte: value},
-            'IN': {in: value},
-            'NOT IN': {notIn: value}
-        };
-        return operatorsMap[upperOperator] || value;
+        return data;
     }
 
-    handleLikeOperator(value, fieldName)
+    async executeWithNormalization(operation, errorMessage, defaultReturn)
     {
-        let cleanValue = String(value).replace(/%/g, '');
-        if(this.typeCaster.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;
-            }
+        try {
+            return this.typeCaster.normalizeReturnData(await operation());
+        } catch(error) {
+            Logger.error(errorMessage+error.message);
+            return defaultReturn;
         }
-        return {contains: cleanValue};
-    }
-
-    handleJsonTextSearch(searchValue)
-    {
-        return {
-            string_contains: searchValue
-        };
-    }
-
-    isJsonField(fieldName)
-    {
-        return this.jsonFields && this.jsonFields.has(fieldName);
     }
 
     async create(params)
     {
-        let preparedData = this.prepareDataWithRelations(params, true);
+        let preparedData = this.prepareData(params, {convertRelations: true, isCreate: true});
         this.ensureRequiredFields(preparedData);
-        try {
-            return await this.model.create({
-                data: preparedData
-            });
-        } catch(error) {
-            Logger.error('Create error: '+error.message);
-            return false;
-        }
+        return this.executeWithNormalization(
+            () => this.model.create({data: preparedData}),
+            'Create error: ',
+            false
+        );
     }
 
     async createWithRelations(params, relations)
@@ -301,69 +242,45 @@ class PrismaDriver extends BaseDriver
         if(0 < relations.length){
             let includeData = this.relationResolver.buildIncludeObjectWithMapping(relations);
             createData.include = includeData.include;
-            for(let relation of relations){
-                let normalizedRelation = this.relationResolver.normalizeRelationName(relation);
-                if(!sc.hasOwn(params, relation) && !sc.hasOwn(params, normalizedRelation)){
-                    continue;
-                }
-                let relationData = sc.get(params, relation, sc.get(params, normalizedRelation, null));
-                if(sc.isArray(relationData)){
-                    createData.data[normalizedRelation] = {
-                        connect: relationData.map(item => ({id: this.typeCaster.castToIdType(item.id)}))
-                    };
-                    continue;
-                }
-                createData.data[normalizedRelation] = {
-                    connect: {id: this.typeCaster.castToIdType(relationData.id)}
-                };
-            }
-            try {
-                return this.relationResolver.transformRelationResults(
+            let relationData = this.relationResolver.buildCreateDataWithRelations(params, relations);
+            createData.data = {...createData.data, ...relationData};
+            return this.executeWithNormalization(
+                async () => this.relationResolver.transformRelationResults(
                     await this.model.create(createData),
                     includeData.include,
                     includeData.mapping
-                );
-            } catch(error) {
-                Logger.error('Create with relations error: '+error.message);
-                return false;
-            }
-        }
-        try {
-            return await this.model.create(createData);
-        } catch(error) {
-            Logger.error('Create with relations error: '+error.message);
-            return false;
-        }
+                ),
+                'Create with relations error: ',
+                false
+            );
+        }
+        return this.executeWithNormalization(
+            () => this.model.create(createData),
+            'Create with relations error: ',
+            false
+        );
     }
 
     async update(filters, updatePatch)
     {
-        let preparedData = this.prepareDataWithRelations(updatePatch);
-        let processedFilters = this.processFilters(filters);
-        try {
-            return await this.model.updateMany({
-                where: processedFilters,
-                data: preparedData
-            });
-        } catch(error) {
-            Logger.error('Update error: '+error.message);
-            return false;
-        }
+        let preparedData = this.prepareData(updatePatch, {skipObjects: true});
+        let processedFilters = this.filterProcessor.processFilters(filters);
+        return this.executeWithNormalization(
+            () => this.model.updateMany({where: processedFilters, data: preparedData}),
+            'Update error: ',
+            false
+        );
     }
 
     async updateBy(field, fieldValue, updatePatch, operator = null)
     {
-        let filter = this.createSingleFilter(field, fieldValue, operator);
-        let preparedData = this.prepareDataWithRelations(updatePatch);
-        try {
-            return await this.model.updateMany({
-                where: filter,
-                data: preparedData
-            });
-        } catch(error) {
-            Logger.error('Update by error: '+error.message);
-            return false;
-        }
+        let filter = this.filterProcessor.createSingleFilter(field, fieldValue, operator);
+        let preparedData = this.prepareData(updatePatch, {skipObjects: true});
+        return this.executeWithNormalization(
+            () => this.model.updateMany({where: filter, data: preparedData}),
+            'Update by error: ',
+            false
+        );
     }
 
     async updateById(id, params)
@@ -373,51 +290,42 @@ class PrismaDriver extends BaseDriver
         if(!found){
             return false;
         }
-        let preparedData = this.prepareDataWithRelations(params);
-        try {
-            return await this.model.update({
-                where: {id: castedId},
-                data: preparedData
-            });
-        } catch(error) {
-            Logger.error('Update by ID error: '+error.message);
-            return false;
-        }
+        let preparedData = this.prepareData(params, {convertRelations: true});
+        return this.executeWithNormalization(
+            () => this.model.update({where: {[this.idFieldName]: castedId}, data: preparedData}),
+            'Update by ID error: ',
+            false
+        );
     }
 
     async upsert(params, filters)
     {
-        let preparedData = this.prepareDataWithRelations(params);
-        let existing = false;
-        if(params.id){
-            let castedId = this.typeCaster.castToIdType(params.id);
-            existing = await this.loadById(castedId);
+        let preparedData = this.prepareData(params, {convertRelations: true});
+        let idValue = params[this.idFieldName];
+        if(idValue){
+            let castedId = this.typeCaster.castToIdType(idValue);
+            let 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;
-                }
+                delete patch[this.idFieldName];
+                return this.executeWithNormalization(
+                    () => this.model.update({where: {[this.idFieldName]: castedId}, data: patch}),
+                    'Upsert update error: ',
+                    false
+                );
             }
         }
         if(filters){
             let existing = await this.loadOne(filters);
             if(existing){
-                try {
-                    return await this.model.update({
-                        where: {id: this.typeCaster.castToIdType(existing.id)},
+                return this.executeWithNormalization(
+                    () => this.model.update({
+                        where: {[this.idFieldName]: this.typeCaster.castToIdType(existing[this.idFieldName])},
                         data: preparedData
-                    });
-                } catch(error) {
-                    Logger.error('Upsert update by filter error: '+error.message);
-                    return false;
-                }
+                    }),
+                    'Upsert update by filter error: ',
+                    false
+                );
             }
         }
         return await this.create(preparedData);
@@ -425,15 +333,12 @@ class PrismaDriver extends BaseDriver
 
     async delete(filters = {})
     {
-        let processedFilters = this.processFilters(filters);
-        try {
-            return await this.model.deleteMany({
-                where: processedFilters
-            });
-        } catch(error) {
-            Logger.error('Delete error: '+error.message);
-            return false;
-        }
+        let processedFilters = this.filterProcessor.processFilters(filters);
+        return this.executeWithNormalization(
+            () => this.model.deleteMany({where: processedFilters}),
+            'Delete error: ',
+            false
+        );
     }
 
     async deleteById(id)
@@ -443,27 +348,21 @@ class PrismaDriver extends BaseDriver
         if(!found){
             return false;
         }
-        try {
-            return await this.model.delete({
-                where: {id: castedId}
-            });
-        } catch(error) {
-            Logger.error('Delete by ID error: '+error.message);
-            return false;
-        }
+        return this.executeWithNormalization(
+            () => this.model.delete({where: {[this.idFieldName]: castedId}}),
+            'Delete by ID error: ',
+            false
+        );
     }
 
     async count(filters)
     {
-        let processedFilters = this.processFilters(filters);
-        try {
-            return await this.model.count({
-                where: processedFilters
-            });
-        } catch(error) {
-            Logger.error('Count error: '+error.message);
-            return 0;
-        }
+        let processedFilters = this.filterProcessor.processFilters(filters);
+        return this.executeWithNormalization(
+            () => this.model.count({where: processedFilters}),
+            'Count error: ',
+            0
+        );
     }
 
     async countWithRelations(filters, relations)
@@ -471,36 +370,32 @@ class PrismaDriver extends BaseDriver
         if(!sc.isArray(relations) || 0 === relations.length){
             relations = this.getAllRelations();
         }
-        let processedFilters = this.processFilters(filters);
-        let query = {
-            where: processedFilters
-        };
+        let processedFilters = this.filterProcessor.processFilters(filters);
+        let query = {where: processedFilters};
         if(0 < relations.length){
             query.include = this.relationResolver.buildIncludeObjectWithMapping(relations).include;
         }
-        try {
-            return await this.model.count(query);
-        } catch(error) {
-            Logger.error('Count with relations error: '+error.message);
-            return 0;
-        }
+        return this.executeWithNormalization(
+            () => this.model.count(query),
+            'Count with relations error: ',
+            0
+        );
     }
 
     async loadAll()
     {
-        try {
-            return await this.model.findMany(this.buildQueryOptions());
-        } catch(error) {
-            Logger.error('Load all error: '+error.message);
-            return [];
-        }
+        return this.executeWithNormalization(
+            () => this.model.findMany(this.queryBuilder.buildQueryOptions(this.getQueryOptions())),
+            'Load all error: ',
+            []
+        );
     }
 
     async loadAllWithRelations(relations)
     {
         return this.executeQueryWithRelations(
             (q) => this.model.findMany(q),
-            this.buildQueryOptions(),
+            this.queryBuilder.buildQueryOptions(this.getQueryOptions()),
             relations,
             'Load all with relations error: ',
             []
@@ -509,21 +404,20 @@ class PrismaDriver extends BaseDriver
 
     async load(filters)
     {
-        let processedFilters = this.processFilters(filters);
-        let query = this.buildQueryOptions();
+        let processedFilters = this.filterProcessor.processFilters(filters);
+        let query = this.queryBuilder.buildQueryOptions(this.getQueryOptions());
         query.where = processedFilters;
-        try {
-            return await this.model.findMany(query);
-        } catch(error) {
-            Logger.error('Load error: '+error.message);
-            return [];
-        }
+        return this.executeWithNormalization(
+            () => this.model.findMany(query),
+            'Load error: ',
+            []
+        );
     }
 
     async loadWithRelations(filters, relations)
     {
-        let query = this.buildQueryOptions();
-        query.where = this.processFilters(filters);
+        let query = this.queryBuilder.buildQueryOptions(this.getQueryOptions());
+        query.where = this.filterProcessor.processFilters(filters);
         return this.executeQueryWithRelations(
             (q) => this.model.findMany(q),
             query,
@@ -535,21 +429,20 @@ class PrismaDriver extends BaseDriver
 
     async loadBy(field, fieldValue, operator = null)
     {
-        let filter = this.createSingleFilter(field, fieldValue, operator);
-        let query = this.buildQueryOptions();
+        let filter = this.filterProcessor.createSingleFilter(field, fieldValue, operator);
+        let query = this.queryBuilder.buildQueryOptions(this.getQueryOptions());
         query.where = filter;
-        try {
-            return await this.model.findMany(query);
-        } catch(error) {
-            Logger.error('Load by error: '+error.message);
-            return [];
-        }
+        return this.executeWithNormalization(
+            () => this.model.findMany(query),
+            'Load by error: ',
+            []
+        );
     }
 
     async loadByWithRelations(field, fieldValue, relations, operator = null)
     {
-        let query = this.buildQueryOptions();
-        query.where = this.createSingleFilter(field, fieldValue, operator);
+        let query = this.queryBuilder.buildQueryOptions(this.getQueryOptions());
+        query.where = this.filterProcessor.createSingleFilter(field, fieldValue, operator);
         return this.executeQueryWithRelations(
             (q) => this.model.findMany(q),
             query,
@@ -562,21 +455,18 @@ class PrismaDriver extends BaseDriver
     async loadById(id)
     {
         let castedId = this.typeCaster.castToIdType(id);
-        try {
-            return await this.model.findUnique({
-                where: {id: castedId}
-            });
-        } catch(error) {
-            Logger.error('Load by ID error: '+error.message);
-            return null;
-        }
+        return this.executeWithNormalization(
+            () => this.model.findUnique({where: {[this.idFieldName]: castedId}}),
+            'Load by ID error: ',
+            null
+        );
     }
 
     async loadByIdWithRelations(id, relations)
     {
         return this.executeQueryWithRelations(
             (q) => this.model.findUnique(q),
-            {where: {id: this.typeCaster.castToIdType(id)}},
+            {where: {[this.idFieldName]: this.typeCaster.castToIdType(id)}},
             relations,
             'Load by ID with relations error: ',
             null
@@ -589,35 +479,29 @@ class PrismaDriver extends BaseDriver
         if(0 === castedIds.length){
             return [];
         }
-        try {
-            return await this.model.findMany({
-                where: {
-                    id: {in: castedIds}
-                }
-            });
-        } catch(error) {
-            Logger.error('Load by IDs error: '+error.message);
-            return [];
-        }
+        return this.executeWithNormalization(
+            () => this.model.findMany({where: {[this.idFieldName]: {in: castedIds}}}),
+            'Load by IDs error: ',
+            []
+        );
     }
 
     async loadOne(filters)
     {
-        let processedFilters = this.processFilters(filters);
-        let query = this.buildQueryOptions(false);
+        let processedFilters = this.filterProcessor.processFilters(filters);
+        let query = this.queryBuilder.buildQueryOptions(this.getQueryOptions(), false);
         query.where = processedFilters;
-        try {
-            return await this.model.findFirst(query);
-        } catch(error) {
-            Logger.error('Load one error: '+error.message);
-            return null;
-        }
+        return this.executeWithNormalization(
+            () => this.model.findFirst(query),
+            'Load one error: ',
+            null
+        );
     }
 
     async loadOneWithRelations(filters, relations)
     {
-        let query = this.buildQueryOptions(false);
-        query.where = this.processFilters(filters);
+        let query = this.queryBuilder.buildQueryOptions(this.getQueryOptions(), false);
+        query.where = this.filterProcessor.processFilters(filters);
         return this.executeQueryWithRelations(
             (q) => this.model.findFirst(q),
             query,
@@ -629,21 +513,20 @@ class PrismaDriver extends BaseDriver
 
     async loadOneBy(field, fieldValue, operator = null)
     {
-        let filter = this.createSingleFilter(field, fieldValue, operator);
-        let query = this.buildQueryOptions(false);
+        let filter = this.filterProcessor.createSingleFilter(field, fieldValue, operator);
+        let query = this.queryBuilder.buildQueryOptions(this.getQueryOptions(), false);
         query.where = filter;
-        try {
-            return await this.model.findFirst(query);
-        } catch(error) {
-            Logger.error('Load one by error: '+error.message);
-            return null;
-        }
+        return this.executeWithNormalization(
+            () => this.model.findFirst(query),
+            'Load one by error: ',
+            null
+        );
     }
 
     async loadOneByWithRelations(field, fieldValue, relations, operator = null)
     {
-        let query = this.buildQueryOptions(false);
-        query.where = this.createSingleFilter(field, fieldValue, operator);
+        let query = this.queryBuilder.buildQueryOptions(this.getQueryOptions(), false);
+        query.where = this.filterProcessor.createSingleFilter(field, fieldValue, operator);
         return this.executeQueryWithRelations(
             (q) => this.model.findFirst(q),
             query,
@@ -653,41 +536,6 @@ class PrismaDriver extends BaseDriver
         );
     }
 
-    buildQueryOptions(useLimit = true)
-    {
-        let queryOptions = {};
-        if(0 < this.select.length){
-            queryOptions.select = {};
-            for(let field of this.select){
-                queryOptions.select[field] = true;
-            }
-        }
-        if(useLimit && 0 !== this.limit){
-            queryOptions.take = this.limit;
-        }
-        if(0 !== this.offset){
-            queryOptions.skip = this.offset;
-        }
-        if(false !== this.sortBy && false !== this.sortDirection){
-            queryOptions.orderBy = {
-                [this.sortBy]: this.sortDirection.toLowerCase()
-            };
-        }
-        return queryOptions;
-    }
-
-    createSingleFilter(field, fieldValue, operator = null)
-    {
-        let filter = {};
-        let processedValue = this.processFilterValue(fieldValue, field);
-        if(null === operator){
-            filter[field] = processedValue;
-            return filter;
-        }
-        filter[field] = {operator, value: processedValue};
-        return this.processFilters(filter);
-    }
-
     async executeQueryWithRelations(modelMethod, query, relations, errorMessage, defaultReturn)
     {
         if(!sc.isArray(relations) || 0 === relations.length){
@@ -697,12 +545,15 @@ class PrismaDriver extends BaseDriver
         if(0 < Object.keys(includeData.include).length){
             query.include = includeData.include;
         }
-        try {
-            return this.relationResolver.transformRelationResults(await modelMethod(query), includeData.include, includeData.mapping);
-        } catch(error) {
-            Logger.error(errorMessage+error.message);
-            return defaultReturn;
-        }
+        return this.executeWithNormalization(
+            async () => this.relationResolver.transformRelationResults(
+                await modelMethod(query),
+                includeData.include,
+                includeData.mapping
+            ),
+            errorMessage,
+            defaultReturn
+        );
     }
 
 }