@reldens/storage 0.88.0 → 0.89.0

package/lib/objection-js/objection-js-driver.js

@@ -67,14 +67,15 @@ class ObjectionJsDriver extends BaseDriver
     async upsert(params, filters)
     {
         if(params.id){
-            let patch = Object.assign({}, params);
-            delete patch.id;
-            return this.queryBuilder().patchAndFetchById(params.id, patch).onConflict().merge();
+            let existent = await this.loadById(params.id);
+            if(existent){
+                return this.updateById(params.id, params);
+            }
         }
         if(filters){
             let existent = await this.loadOne(filters);
             if(existent){
-                return this.queryBuilder().patchAndFetchById(existent.id, params).onConflict().merge();
+                return this.updateById(existent.id, params);
             }
         }
         return this.create(params);
@@ -103,7 +104,7 @@ class ObjectionJsDriver extends BaseDriver
     {
         let queryBuilder = this.queryBuilder(true, true, true);
         this.appendFilters(queryBuilder, filters);
-        let count = await this.appendRelationsToQuery(queryBuilder, relations).count().first();
+        let count = await this.appendRelationsToQuery(queryBuilder, relations, null, this.containsRelationFilters(filters)).count().first();
         return count ? count['count(*)'] : 0;
     }
 
@@ -128,7 +129,7 @@ class ObjectionJsDriver extends BaseDriver
     {
         let queryBuilder = this.queryBuilder(true, true, true);
         this.appendFilters(queryBuilder, filters);
-        return this.appendRelationsToQuery(queryBuilder, relations);
+        return this.appendRelationsToQuery(queryBuilder, relations, null, this.containsRelationFilters(filters));
     }
 
     loadBy(field, fieldValue, operator = null)
@@ -171,7 +172,12 @@ class ObjectionJsDriver extends BaseDriver
     {
         let queryBuilder = this.queryBuilder(false, true, true);
         this.appendFilters(queryBuilder, filters);
-        return this.appendRelationsToQuery(queryBuilder, relations).limit(1).first();
+        return this.appendRelationsToQuery(
+            queryBuilder,
+            relations,
+            null,
+            this.containsRelationFilters(filters)
+        ).limit(1).first();
     }
 
     loadOneBy(field, fieldValue, operator = null)
@@ -200,7 +206,7 @@ class ObjectionJsDriver extends BaseDriver
         if(useOffset && 0 !== this.offset){
             queryBuilder.offset(this.offset)
         }
-        if(useSort && false !== this.sortBy && false !== this.sortDirection){
+        if(useSort && this.sortBy && this.sortDirection){
             queryBuilder.orderBy(this.sortBy, this.sortDirection)
         }
         return queryBuilder;
@@ -231,6 +237,45 @@ class ObjectionJsDriver extends BaseDriver
         queryBuilder.where(field, 'like', '%' + cleanValue + '%');
     }
 
+    isRelationField(fieldName)
+    {
+        let relationMappings = sc.get(this.rawModel, 'relationMappings', false);
+        if(!relationMappings){
+            return false;
+        }
+        if('function' === typeof relationMappings){
+            relationMappings = relationMappings();
+        }
+        return sc.hasOwn(relationMappings, fieldName);
+    }
+
+    flattenRelationFilters(relationName, nestedFilters)
+    {
+        let flattened = {};
+        for(let key of Object.keys(nestedFilters)){
+            let value = nestedFilters[key];
+            if('OR' === key && sc.isArray(value)){
+                flattened.OR = this.flattenOrConditions(relationName, value);
+                continue;
+            }
+            flattened[relationName+'.'+key] = value;
+        }
+        return flattened;
+    }
+
+    flattenOrConditions(relationName, conditions)
+    {
+        let flattenedConditions = [];
+        for(let condition of conditions){
+            let flatCondition = {};
+            for(let condKey of Object.keys(condition)){
+                flatCondition[relationName+'.'+condKey] = condition[condKey];
+            }
+            flattenedConditions.push(flatCondition);
+        }
+        return flattenedConditions;
+    }
+
     appendFilters(queryBuilder, filters = {})
     {
         let filtersKeys = Object.keys(filters);
@@ -239,17 +284,25 @@ class ObjectionJsDriver extends BaseDriver
         }
         for(let i of filtersKeys){
             let filter = filters[i];
+            if('AND' === i && sc.isArray(filter)){
+                for(let condition of filter){
+                    queryBuilder.where((nestedQb) => {
+                        this.appendFilters(nestedQb, condition);
+                    });
+                }
+                continue;
+            }
             if('OR' === i && sc.isArray(filter)){
-                queryBuilder.where(function(){
+                queryBuilder.where((outerQb) => {
                     for(let condition of filter){
-                        this.orWhere(function(){
-                            this.appendFilters(this, condition);
-                        }.bind(this));
+                        outerQb.orWhere((innerQb) => {
+                            this.appendFilters(innerQb, condition);
+                        });
                     }
-                }.bind(this));
+                });
                 continue;
             }
-            let filterOperator = sc.get(filter, 'operator');
+            let filterOperator = sc.get(filter, 'operator', '').toUpperCase();
             if(filterOperator){
                 if('OR' === filterOperator){
                     queryBuilder.orWhere(i, filter.value);
@@ -267,7 +320,13 @@ class ObjectionJsDriver extends BaseDriver
                     this.handleLikeFilter(queryBuilder, i, filter.value);
                     continue;
                 }
-                queryBuilder.where(i, filter.operator, filter.value);
+                let sqlOperator = this.operatorsMap[filterOperator] || filter.operator;
+                queryBuilder.where(i, sqlOperator, filter.value);
+                continue;
+            }
+            if(this.isRelationField(i) && sc.isObject(filter) && !sc.isArray(filter)){
+                let flattenedFilters = this.flattenRelationFilters(i, filter);
+                this.appendFilters(queryBuilder, flattenedFilters);
                 continue;
             }
             queryBuilder.where(i, filter);
@@ -275,18 +334,51 @@ class ObjectionJsDriver extends BaseDriver
         return queryBuilder;
     }
 
-    appendRelationsToQuery(queryBuilder, relations, relationsModifiers)
+    containsRelationFilters(filters)
+    {
+        if(!sc.isObject(filters)){
+            return false;
+        }
+        for(let key of Object.keys(filters)){
+            if('AND' === key || 'OR' === key){
+                if(sc.isArray(filters[key])){
+                    for(let condition of filters[key]){
+                        if(this.containsRelationFilters(condition)){
+                            return true;
+                        }
+                    }
+                }
+                continue;
+            }
+            if(this.isRelationField(key)){
+                return true;
+            }
+        }
+        return false;
+    }
+
+    appendRelationsToQuery(queryBuilder, relations, relationsModifiers, useJoin = false)
     {
         if(!sc.isArray(relations) || 0 === relations.length){
             relations = Object.keys(this.rawModel.relationMappings || {});
         }
-        if(0 < relations.length){
-            queryBuilder.withGraphFetched('['+relations.join(',')+']');
-        }
+        this.applyGraphMethod(relations, useJoin, queryBuilder);
         this.appendRelationsModifiers(queryBuilder, relations, relationsModifiers);
         return queryBuilder;
     }
 
+    applyGraphMethod(relations, useJoin, queryBuilder)
+    {
+        if(0 === relations.length){
+            return;
+        }
+        if(useJoin){
+            queryBuilder.withGraphJoined('[' + relations.join(',') + ']');
+            return;
+        }
+        queryBuilder.withGraphFetched('[' + relations.join(',') + ']');
+    }
+
     appendRelationsModifiers(queryBuilder, relations, relationsModifiers)
     {
         if(!sc.isArray(relationsModifiers)){

package/lib/prisma/prisma-data-server.js

@@ -7,7 +7,7 @@
 const { BaseDataServer } = require('../base-data-server');
 const { PrismaDriver } = require('./prisma-driver');
 const { MySQLTablesProvider } = require('../mysql-tables-provider');
-const { PrismaClient } = require('@prisma/client');
+const { PrismaClient, Prisma } = require('@prisma/client');
 const { FileHandler } = require('@reldens/server-utils');
 const { Logger, sc } = require('@reldens/utils');
 
@@ -91,7 +91,8 @@ class PrismaDataServer extends BaseDataServer
                 prisma: this.prisma,
                 model: prismaModel,
                 server: this,
-                allRelationMappings: this.allRelationMappings
+                allRelationMappings: this.allRelationMappings,
+                prismaDbNull: Prisma.DbNull
             });
         }
         this.entityManager.setEntities(this.entities);

package/lib/prisma/prisma-driver.js

@@ -29,6 +29,7 @@ class PrismaDriver extends BaseDriver
         this.prisma = props.prisma;
         this.model = props.model;
         this.allRelationMappings = sc.get(props, 'allRelationMappings', {});
+        this.prismaDbNull = sc.get(props, 'prismaDbNull', null);
         this.initHelpers();
         this.initModelMetadata();
     }
@@ -46,7 +47,8 @@ class PrismaDriver extends BaseDriver
             fieldDefaults: {},
             requiredFields: [],
             optionalFields: [],
-            rawModel: this.rawModel
+            rawModel: this.rawModel,
+            prismaDbNull: this.prismaDbNull
         });
         this.relationResolver = new PrismaRelationResolver({
             relationMetadata: {},
@@ -60,7 +62,9 @@ class PrismaDriver extends BaseDriver
             typeCaster: this.typeCaster,
             fieldTypes: {},
             referenceFields: {},
-            jsonFields: new Set()
+            jsonFields: new Set(),
+            operatorsMap: this.operatorsMap,
+            relationResolver: this.relationResolver
         });
         this.queryBuilder = new PrismaQueryBuilder();
     }
@@ -237,6 +241,11 @@ class PrismaDriver extends BaseDriver
             relations = this.getAllRelations();
         }
         let preparedData = this.prepareData(params);
+        for(let relation of relations){
+            if(sc.hasOwn(preparedData, relation)){
+                delete preparedData[relation];
+            }
+        }
         this.ensureRequiredFields(preparedData);
         let createData = {data: preparedData};
         if(0 < relations.length){
@@ -367,16 +376,9 @@ class PrismaDriver extends BaseDriver
 
     async countWithRelations(filters, relations)
     {
-        if(!sc.isArray(relations) || 0 === relations.length){
-            relations = this.getAllRelations();
-        }
         let processedFilters = this.filterProcessor.processFilters(filters);
-        let query = {where: processedFilters};
-        if(0 < relations.length){
-            query.include = this.relationResolver.buildIncludeObjectWithMapping(relations).include;
-        }
         return this.executeWithNormalization(
-            () => this.model.count(query),
+            () => this.model.count({where: processedFilters}),
             'Count with relations error: ',
             0
         );

package/lib/prisma/prisma-filter-processor.js

@@ -1,146 +1,193 @@
-/**
- *
- * Reldens - PrismaFilterProcessor
- *
- */
-
-const { sc } = require('@reldens/utils');
-
-class PrismaFilterProcessor
-{
-
-    constructor(props)
-    {
-        this.typeCaster = sc.get(props, 'typeCaster', null);
-        this.fieldTypes = sc.get(props, 'fieldTypes', {});
-        this.referenceFields = sc.get(props, 'referenceFields', {});
-        this.jsonFields = sc.get(props, 'jsonFields', new Set());
-    }
-
-    updateMetadata(metadata)
-    {
-        this.fieldTypes = sc.get(metadata, 'fieldTypes', this.fieldTypes);
-        this.referenceFields = sc.get(metadata, 'referenceFields', this.referenceFields);
-        this.jsonFields = sc.get(metadata, 'jsonFields', this.jsonFields);
-    }
-
-    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));
-                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.isObject(value) && !sc.isArray(value)){
-                processedFilters[key] = this.processFilters(value);
-                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 => this.typeCaster.isValidCastedValue(val));
-            }
-            return value;
-        }
-        if('id' === key){
-            return this.typeCaster.castToIdType(value);
-        }
-        let fieldType = this.fieldTypes[key];
-        if(!fieldType){
-            return value;
-        }
-        let castedValue = this.typeCaster.castValue(value, fieldType, key);
-        if(this.typeCaster.isValidCastedValue(castedValue)){
-            return castedValue;
-        }
-        return value;
-    }
-
-    applyOperator(value, operator, fieldName = null)
-    {
-        let upperOperator = operator ? operator.toUpperCase() : '';
-        if('LIKE' === upperOperator){
-            return this.handleLikeOperator(value, fieldName);
-        }
-        let operatorsMap = {
-            '=': value,
-            '!=': {not: value},
-            '>': {gt: value},
-            '>=': {gte: value},
-            '<': {lt: value},
-            '<=': {lte: value},
-            'IN': {in: value},
-            'NOT IN': {notIn: value}
-        };
-        return operatorsMap[upperOperator] || value;
-    }
-
-    handleLikeOperator(value, fieldName)
-    {
-        let cleanValue = String(value).replace(/%/g, '');
-        if(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: cleanValue};
-    }
-
-    handleJsonTextSearch(searchValue)
-    {
-        return {
-            string_contains: searchValue
-        };
-    }
-
-    isJsonField(fieldName)
-    {
-        if(!this.jsonFields){
-            return false;
-        }
-        if(this.jsonFields.has(fieldName)){
-            return true;
-        }
-        return this.typeCaster && this.typeCaster.isJsonFieldByName(fieldName);
-    }
-
-    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);
-    }
-
-}
-
-module.exports.PrismaFilterProcessor = PrismaFilterProcessor;
+/**
+ *
+ * Reldens - PrismaFilterProcessor
+ *
+ */
+
+const { sc } = require('@reldens/utils');
+
+class PrismaFilterProcessor
+{
+
+    constructor(props)
+    {
+        this.typeCaster = sc.get(props, 'typeCaster', null);
+        this.fieldTypes = sc.get(props, 'fieldTypes', {});
+        this.referenceFields = sc.get(props, 'referenceFields', {});
+        this.jsonFields = sc.get(props, 'jsonFields', new Set());
+        this.operatorsMap = sc.get(props, 'operatorsMap', {});
+        this.relationResolver = sc.get(props, 'relationResolver', null);
+    }
+
+    updateMetadata(metadata)
+    {
+        this.fieldTypes = sc.get(metadata, 'fieldTypes', this.fieldTypes);
+        this.referenceFields = sc.get(metadata, 'referenceFields', this.referenceFields);
+        this.jsonFields = sc.get(metadata, 'jsonFields', this.jsonFields);
+        this.relationResolver = sc.get(metadata, 'relationResolver', this.relationResolver);
+    }
+
+    processFilters(filters)
+    {
+        if(!sc.isObject(filters)){
+            return filters;
+        }
+        let processedFilters = {};
+        for(let key of Object.keys(filters)){
+            let value = filters[key];
+            if('AND' === key && sc.isArray(value)){
+                processedFilters.AND = value.map(condition => this.processFilters(condition));
+                continue;
+            }
+            if('OR' === key && sc.isArray(value)){
+                processedFilters.OR = value.map(condition => this.processFilters(condition));
+                continue;
+            }
+            let translatedKey = this.translateRelationKey(key);
+            if(sc.hasOwn(value, 'operator') && sc.hasOwn(value, 'value')){
+                let operatorValue = this.processFilterValue(value.value, translatedKey);
+                processedFilters[translatedKey] = this.applyOperator(operatorValue, value.operator, translatedKey);
+                continue;
+            }
+            if(sc.isObject(value) && !sc.isArray(value)){
+                if(this.isRelationKey(key)){
+                    processedFilters[translatedKey] = {
+                        some: this.processFilters(value)
+                    };
+                    continue;
+                }
+                processedFilters[translatedKey] = this.processFilters(value);
+                continue;
+            }
+            processedFilters[translatedKey] = this.processFilterValue(value, translatedKey);
+        }
+        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 => this.typeCaster.isValidCastedValue(val));
+            }
+            return value;
+        }
+        if('id' === key){
+            return this.typeCaster.castToIdType(value);
+        }
+        let fieldType = this.fieldTypes[key];
+        if(!fieldType){
+            return value;
+        }
+        let castedValue = this.typeCaster.castValue(value, fieldType, key);
+        if(this.typeCaster.isValidCastedValue(castedValue)){
+            return castedValue;
+        }
+        return value;
+    }
+
+    applyOperator(value, operator, fieldName = null)
+    {
+        let upperOperator = operator ? operator.toUpperCase() : '';
+        if('LIKE' === upperOperator){
+            return this.handleLikeOperator(value, fieldName);
+        }
+        if('IN' === upperOperator){
+            return {in: value};
+        }
+        if('NOT IN' === upperOperator){
+            return {notIn: value};
+        }
+        if('NOT' === upperOperator){
+            return {not: value};
+        }
+        let sqlOperator = this.operatorsMap[upperOperator] || upperOperator;
+        let prismaSyntaxMap = {
+            '=': value,
+            '!=': {not: value},
+            '>': {gt: value},
+            '>=': {gte: value},
+            '<': {lt: value},
+            '<=': {lte: value}
+        };
+        return prismaSyntaxMap[sqlOperator] || value;
+    }
+
+    handleLikeOperator(value, fieldName)
+    {
+        let cleanValue = String(value).replace(/%/g, '');
+        if(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: cleanValue};
+    }
+
+    handleJsonTextSearch(searchValue)
+    {
+        return {
+            string_contains: searchValue
+        };
+    }
+
+    isJsonField(fieldName)
+    {
+        if(!this.jsonFields){
+            return false;
+        }
+        if(this.jsonFields.has(fieldName)){
+            return true;
+        }
+        return this.typeCaster && this.typeCaster.isJsonFieldByName(fieldName);
+    }
+
+    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);
+    }
+
+    translateRelationKey(key)
+    {
+        if(!this.relationResolver){
+            return key;
+        }
+        let prismaName = this.relationResolver.mapToPrismaName(key, null);
+        if(prismaName){
+            return prismaName;
+        }
+        return key;
+    }
+
+    isRelationKey(key)
+    {
+        if(!this.relationResolver){
+            return false;
+        }
+        let prismaName = this.relationResolver.mapToPrismaName(key, null);
+        if(prismaName && prismaName !== key){
+            return true;
+        }
+        let relationMetadata = sc.get(this.relationResolver, 'relationMetadata', {});
+        return sc.hasOwn(relationMetadata, key);
+    }
+
+}
+
+module.exports.PrismaFilterProcessor = PrismaFilterProcessor;

package/lib/prisma/prisma-metadata-loader.js

@@ -5,7 +5,6 @@
  */
 
 const { Logger, sc } = require('@reldens/utils');
-const { Prisma } = require('@prisma/client');
 
 class PrismaMetadataLoader
 {
@@ -28,9 +27,6 @@ class PrismaMetadataLoader
             if(this.prisma._runtimeDataModel){
                 return this.prisma._runtimeDataModel;
             }
-            if(Prisma.dmmf && Prisma.dmmf.datamodel){
-                return Prisma.dmmf.datamodel;
-            }
             return null;
         } catch(error) {
             Logger.warning('Failed to access DMMF: '+error.message);