@reldens/storage 0.81.0 → 0.82.0

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

@@ -0,0 +1,146 @@
+/**
+ *
+ * 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;

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

@@ -57,9 +57,11 @@ class PrismaMetadataLoader
             fieldTypes: {},
             fieldDefaults: {},
             idFieldType: 'String',
+            idFieldName: 'id',
             referenceFields: {},
             relationMetadata: {},
             foreignKeyMappings: {},
+            foreignKeyTargetFields: {},
             jsonFields: new Set()
         };
         for(let field of modelInfo.fields){
@@ -83,6 +85,7 @@ class PrismaMetadataLoader
         }
         if(field.isId){
             metadata.idFieldType = field.type;
+            metadata.idFieldName = field.name;
         }
         if(field.hasDefaultValue){
             metadata.fieldDefaults[field.name] = field.default;
@@ -110,8 +113,12 @@ class PrismaMetadataLoader
             };
         }
         if('object' === field.kind && sc.hasOwn(field, 'relationFromFields') && sc.isArray(field.relationFromFields)){
+            let relationToFields = sc.get(field, 'relationToFields', []);
+            let index = 0;
             for(let foreignKeyField of field.relationFromFields){
                 metadata.foreignKeyMappings[foreignKeyField] = field.name;
+                metadata.foreignKeyTargetFields[foreignKeyField] = relationToFields[index] || 'id';
+                index++;
             }
         }
     }

package/lib/prisma/prisma-query-builder.js

@@ -0,0 +1,42 @@
+/**
+ *
+ * Reldens - PrismaQueryBuilder
+ *
+ */
+
+const { sc } = require('@reldens/utils');
+
+class PrismaQueryBuilder
+{
+
+    buildQueryOptions(options, useLimit = true)
+    {
+        let select = sc.get(options, 'select', []);
+        let limit = sc.get(options, 'limit', 0);
+        let offset = sc.get(options, 'offset', 0);
+        let sortBy = sc.get(options, 'sortBy', false);
+        let sortDirection = sc.get(options, 'sortDirection', 'ASC');
+        let queryOptions = {};
+        if(0 < select.length){
+            queryOptions.select = {};
+            for(let field of select){
+                queryOptions.select[field] = true;
+            }
+        }
+        if(useLimit && 0 !== limit){
+            queryOptions.take = limit;
+        }
+        if(0 !== offset){
+            queryOptions.skip = offset;
+        }
+        if(false !== sortBy && false !== sortDirection){
+            queryOptions.orderBy = {
+                [sortBy]: sortDirection.toLowerCase()
+            };
+        }
+        return queryOptions;
+    }
+
+}
+
+module.exports.PrismaQueryBuilder = PrismaQueryBuilder;

package/lib/prisma/prisma-relation-resolver.js

@@ -12,61 +12,36 @@ class PrismaRelationResolver
     constructor(props)
     {
         this.relationMetadata = sc.get(props, 'relationMetadata', {});
-        this.relationAliases = sc.get(props, 'relationAliases', {});
         this.metadataLoader = sc.get(props, 'metadataLoader', null);
+        this.allRelationMappings = sc.get(props, 'allRelationMappings', {});
+        this.foreignKeyMappings = sc.get(props, 'foreignKeyMappings', {});
+        this.foreignKeyTargetFields = sc.get(props, 'foreignKeyTargetFields', {});
+        this.typeCaster = sc.get(props, 'typeCaster', null);
+        this.currentModelMappings = {};
+        this.reverseModelMappings = {};
     }
 
     updateMetadata(metadata)
     {
         this.relationMetadata = sc.get(metadata, 'relationMetadata', this.relationMetadata);
-        this.relationAliases = sc.get(metadata, 'relationAliases', this.relationAliases);
+        this.foreignKeyMappings = sc.get(metadata, 'foreignKeyMappings', this.foreignKeyMappings);
+        this.foreignKeyTargetFields = sc.get(metadata, 'foreignKeyTargetFields', this.foreignKeyTargetFields);
     }
 
-    buildRelationAliases(tableName)
+    setCurrentModelMappings(mappings)
     {
-        let normalizedTableName = tableName.toLowerCase();
-        for(let prismaRelation of Object.keys(this.relationMetadata)){
-            let meta = this.relationMetadata[prismaRelation];
-            let relatedModel = meta.model.toLowerCase();
-            let aliases = this.generateRelationAliases(prismaRelation, relatedModel, normalizedTableName);
-            for(let alias of aliases){
-                this.relationAliases[alias] = prismaRelation;
-            }
-        }
-        return this.relationAliases;
+        this.currentModelMappings = mappings || {};
+        this.reverseModelMappings = this.buildReverseMappings(this.currentModelMappings);
     }
 
-    generateRelationAliases(prismaRelation, relatedModel, tableName)
+    buildReverseMappings(mappings)
     {
-        let aliases = [];
-        aliases.push('related_'+relatedModel);
-        aliases.push(relatedModel);
-        let fkHint = this.extractForeignKeyHint(prismaRelation, relatedModel, tableName);
-        if(fkHint){
-            aliases.push('related_'+relatedModel+'_'+fkHint);
-            aliases.push(relatedModel+'_'+fkHint);
+        let reverse = {};
+        for(let reldensName of Object.keys(mappings)){
+            let prismaName = mappings[reldensName];
+            reverse[prismaName] = reldensName;
         }
-        return aliases;
-    }
-
-    extractForeignKeyHint(prismaRelation, relatedModel, tableName)
-    {
-        let toSuffix = 'To'+tableName;
-        if(!prismaRelation.toLowerCase().endsWith(toSuffix.toLowerCase())){
-            return null;
-        }
-        let withoutToSuffix = prismaRelation.slice(0, -toSuffix.length);
-        let prefix = relatedModel+'_';
-        if(withoutToSuffix.toLowerCase().startsWith(prefix.toLowerCase())){
-            withoutToSuffix = withoutToSuffix.slice(prefix.length);
-            if(withoutToSuffix.toLowerCase().startsWith(prefix.toLowerCase())){
-                withoutToSuffix = withoutToSuffix.slice(prefix.length);
-            }
-        }
-        if(withoutToSuffix.endsWith('_id')){
-            return withoutToSuffix.slice(0, -3);
-        }
-        return withoutToSuffix;
+        return reverse;
     }
 
     getAllRelations()
@@ -74,151 +49,148 @@ class PrismaRelationResolver
         return Object.keys(this.relationMetadata || {});
     }
 
-    normalizeRelationName(relationName)
+    mapToPrismaName(reldensName, modelName)
     {
-        if(sc.hasOwn(this.relationMetadata, relationName)){
-            return relationName;
-        }
-        if(sc.hasOwn(this.relationAliases, relationName)){
-            return this.relationAliases[relationName];
-        }
-        if(relationName.startsWith('related_')){
-            let withoutPrefix = relationName.substring(8);
-            if(sc.hasOwn(this.relationMetadata, withoutPrefix)){
-                return withoutPrefix;
+        if(!modelName){
+            if(sc.hasOwn(this.relationMetadata, reldensName)){
+                return reldensName;
             }
-            if(sc.hasOwn(this.relationAliases, withoutPrefix)){
-                return this.relationAliases[withoutPrefix];
+            if(sc.hasOwn(this.currentModelMappings, reldensName)){
+                return this.currentModelMappings[reldensName];
             }
+            return null;
         }
-        let availableRelations = Object.keys(this.relationMetadata);
-        for(let availableRelation of availableRelations){
-            if(relationName.endsWith(availableRelation)){
-                return availableRelation;
-            }
-            if(availableRelation.endsWith(relationName.replace('related_', ''))){
-                return availableRelation;
-            }
+        let modelMappings = sc.get(this.allRelationMappings, modelName.toLowerCase(), {});
+        if(sc.hasOwn(modelMappings, reldensName)){
+            return modelMappings[reldensName];
         }
-        return relationName;
+        return null;
     }
 
-    buildIncludeObjectWithMapping(relations)
+    mapToReldensName(prismaName)
     {
-        let include = {};
-        let mapping = {};
-        for(let relation of relations){
-            if(-1 !== relation.indexOf('.')){
-                this.buildNestedInclude(relation, include, mapping);
-                continue;
-            }
-            let normalizedRelation = this.normalizeRelationName(relation);
-            if(!sc.hasOwn(this.relationMetadata, normalizedRelation)){
-                continue;
-            }
-            include[normalizedRelation] = true;
-            if(relation !== normalizedRelation){
-                mapping[normalizedRelation] = relation;
-            }
+        if(sc.hasOwn(this.reverseModelMappings, prismaName)){
+            return this.reverseModelMappings[prismaName];
         }
-        return {include, mapping};
+        return prismaName;
     }
 
-    buildNestedInclude(relationPath, include, mapping)
+    getRelatedModelName(prismaName, fromModelName)
     {
-        let parts = relationPath.split('.');
-        let rootPart = parts.shift();
-        let normalizedRoot = this.normalizeRelationName(rootPart);
-        if(!sc.hasOwn(this.relationMetadata, normalizedRoot)){
-            return;
-        }
-        if(!sc.hasOwn(include, normalizedRoot) || true === include[normalizedRoot]){
-            include[normalizedRoot] = {include: {}};
-        }
-        if(rootPart !== normalizedRoot){
-            mapping[normalizedRoot] = rootPart;
-        }
-        if(0 === parts.length){
-            return;
+        if(!fromModelName){
+            let meta = sc.get(this.relationMetadata, prismaName, null);
+            if(meta){
+                return meta.model;
+            }
+            return null;
         }
-        let nestedPath = parts.join('.');
-        let relatedModel = this.relationMetadata[normalizedRoot].model;
-        this.buildNestedIncludeForModel(nestedPath, include[normalizedRoot].include, mapping, relatedModel);
-    }
-
-    buildNestedIncludeForModel(relationPath, include, mapping, modelName)
-    {
         if(!this.metadataLoader){
-            return;
+            return null;
         }
         let dmmf = this.metadataLoader.getDmmf();
         if(!dmmf){
-            return;
+            return null;
         }
-        let modelInfo = dmmf.models?.[modelName.toLowerCase()]
-            || dmmf.models?.find(m => m.name.toLowerCase() === modelName.toLowerCase());
+        let modelInfo = this.findModelInDmmf(dmmf, fromModelName);
         if(!modelInfo){
-            return;
+            return null;
         }
-        let relationFields = {};
-        let tableName = modelName.toLowerCase();
         for(let field of modelInfo.fields){
-            if('object' === field.kind){
-                relationFields[field.name] = {
-                    model: field.type,
-                    isList: field.isList
-                };
+            if(field.name === prismaName && 'object' === field.kind){
+                return field.type;
             }
         }
-        let parts = relationPath.split('.');
-        let currentPart = parts.shift();
-        let normalizedPart = this.normalizeNestedRelation(currentPart, relationFields, tableName);
-        if(!normalizedPart){
-            return;
+        return null;
+    }
+
+    findModelInDmmf(dmmf, modelName)
+    {
+        let lowerName = modelName.toLowerCase();
+        if(sc.hasOwn(dmmf.models, lowerName)){
+            return dmmf.models[lowerName];
         }
-        if(0 === parts.length){
-            include[normalizedPart] = true;
-            if(currentPart !== normalizedPart){
-                mapping[normalizedPart] = currentPart;
+        if(sc.isArray(dmmf.models)){
+            for(let model of dmmf.models){
+                if(model.name.toLowerCase() === lowerName){
+                    return model;
+                }
             }
-            return;
-        }
-        if(!sc.hasOwn(include, normalizedPart) || true === include[normalizedPart]){
-            include[normalizedPart] = {include: {}};
-        }
-        if(currentPart !== normalizedPart){
-            mapping[normalizedPart] = currentPart;
         }
-        let nestedPath = parts.join('.');
-        let nestedModel = relationFields[normalizedPart].model;
-        this.buildNestedIncludeForModel(nestedPath, include[normalizedPart].include, mapping, nestedModel);
+        return null;
     }
 
-    normalizeNestedRelation(relationName, relationFields, tableName)
+    convertForeignKeysToRelations(params, isCreate = false)
     {
-        if(sc.hasOwn(relationFields, relationName)){
-            return relationName;
+        let data = {};
+        let relations = {};
+        for(let key of Object.keys(params)){
+            if(!sc.hasOwn(this.foreignKeyMappings, key)){
+                data[key] = params[key];
+                continue;
+            }
+            let relationName = this.foreignKeyMappings[key];
+            let value = params[key];
+            let targetField = sc.get(this.foreignKeyTargetFields, key, 'id');
+            if(!this.typeCaster){
+                relations[relationName] = {connect: {[targetField]: value}};
+                continue;
+            }
+            if(this.typeCaster.isNullOrEmpty(value)){
+                if(isCreate){
+                    continue;
+                }
+                relations[relationName] = {disconnect: true};
+                continue;
+            }
+            let fieldType = sc.get(this.typeCaster.fieldTypes, key, null);
+            let connectValue = fieldType
+                ? this.typeCaster.castValue(value, fieldType, key)
+                : this.typeCaster.castToIdType(value);
+            relations[relationName] = {
+                connect: {[targetField]: connectValue}
+            };
         }
-        let cleanName = relationName.replace('related_', '');
-        if(sc.hasOwn(relationFields, cleanName)){
-            return cleanName;
+        return {...data, ...relations};
+    }
+
+    buildIncludeObjectWithMapping(relations)
+    {
+        let include = {};
+        let mapping = {};
+        for(let relation of relations){
+            this.processRelationPath(relation, include, mapping);
         }
-        for(let fieldName of Object.keys(relationFields)){
-            let relatedModel = relationFields[fieldName].model.toLowerCase();
-            let fkHint = this.extractForeignKeyHint(fieldName, relatedModel, tableName);
-            if(fkHint){
-                let possibleNames = [
-                    'related_'+relatedModel+'_'+fkHint,
-                    relatedModel+'_'+fkHint,
-                    'related_'+relatedModel,
-                    relatedModel
-                ];
-                if(-1 !== possibleNames.indexOf(cleanName) || -1 !== possibleNames.indexOf(relationName)){
-                    return fieldName;
-                }
+        return {include, mapping};
+    }
+
+    processRelationPath(relationPath, include, mapping)
+    {
+        let parts = relationPath.split('.');
+        let currentInclude = include;
+        let currentModelName = null;
+        for(let i = 0; i < parts.length; i++){
+            let reldensName = parts[i];
+            let prismaName = this.mapToPrismaName(reldensName, currentModelName);
+            if(!prismaName){
+                return;
+            }
+            if(reldensName !== prismaName){
+                mapping[prismaName] = reldensName;
+            }
+            let isLastPart = (i === parts.length - 1);
+            if(isLastPart){
+                currentInclude[prismaName] = true;
+                return;
+            }
+            if(!sc.hasOwn(currentInclude, prismaName) || true === currentInclude[prismaName]){
+                currentInclude[prismaName] = {include: {}};
+            }
+            currentModelName = this.getRelatedModelName(prismaName, currentModelName);
+            if(!currentModelName){
+                return;
             }
+            currentInclude = currentInclude[prismaName].include;
         }
-        return null;
     }
 
     transformRelationResults(result, includeConfig, relationMapping)
@@ -238,28 +210,56 @@ class PrismaRelationResolver
             return item;
         }
         let transformed = {...item};
-        for(let relationName of Object.keys(includeConfig)){
-            if(!sc.hasOwn(transformed, relationName)){
+        for(let prismaName of Object.keys(includeConfig)){
+            if(!sc.hasOwn(transformed, prismaName)){
                 continue;
             }
-            let relationMeta = this.relationMetadata[relationName];
-            if(!relationMeta){
+            let relationValue = transformed[prismaName];
+            let nestedConfig = includeConfig[prismaName];
+            if(sc.isObject(nestedConfig) && sc.hasOwn(nestedConfig, 'include')){
+                relationValue = this.transformRelationResults(relationValue, nestedConfig.include, relationMapping);
+            }
+            let reldensName = sc.get(relationMapping, prismaName, null);
+            if(!reldensName){
+                reldensName = this.mapToReldensName(prismaName);
+            }
+            transformed[reldensName] = relationValue;
+            if(reldensName !== prismaName){
+                delete transformed[prismaName];
+            }
+        }
+        return transformed;
+    }
+
+    buildCreateDataWithRelations(params, relations)
+    {
+        let createData = {};
+        for(let relation of relations){
+            let prismaName = this.mapToPrismaName(relation, null);
+            if(!prismaName){
                 continue;
             }
-            let relationValue = transformed[relationName];
-            if('one' === relationMeta.type && sc.isArray(relationValue)){
-                relationValue = 0 < relationValue.length ? [...relationValue].shift() : null;
+            if(!sc.hasOwn(params, relation)){
+                continue;
             }
-            if('many' === relationMeta.type && !sc.isArray(relationValue)){
-                relationValue = relationValue ? [relationValue] : [];
+            let relationData = params[relation];
+            if(!this.typeCaster){
+                createData[prismaName] = sc.isArray(relationData)
+                    ? {connect: relationData.map(item => ({id: item.id}))}
+                    : {connect: {id: relationData.id}};
+                continue;
             }
-            let originalName = sc.get(relationMapping, relationName, relationName);
-            transformed[originalName] = relationValue;
-            if(originalName !== relationName){
-                delete transformed[relationName];
+            if(sc.isArray(relationData)){
+                createData[prismaName] = {
+                    connect: relationData.map(item => ({id: this.typeCaster.castToIdType(item.id)}))
+                };
+                continue;
             }
+            createData[prismaName] = {
+                connect: {id: this.typeCaster.castToIdType(relationData.id)}
+            };
         }
-        return transformed;
+        return createData;
     }
 
 }