@reldens/storage 0.80.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

@@ -0,0 +1,133 @@
+/**
+ *
+ * Reldens - PrismaMetadataLoader
+ *
+ */
+
+const { Logger, sc } = require('@reldens/utils');
+const { Prisma } = require('@prisma/client');
+
+class PrismaMetadataLoader
+{
+
+    constructor(props)
+    {
+        this.prisma = sc.get(props, 'prisma', null);
+        this.rawModel = sc.get(props, 'rawModel', null);
+    }
+
+    getDmmf()
+    {
+        try {
+            if(this.prisma._dmmf){
+                return this.prisma._dmmf.datamodel;
+            }
+            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('Failed to access DMMF: '+error.message);
+            return null;
+        }
+    }
+
+    loadModelMetadata(tableName)
+    {
+        let dmmf = this.getDmmf();
+        if(!dmmf){
+            Logger.warning('Could not access Prisma DMMF metadata');
+            return null;
+        }
+        let modelName = 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 null;
+        }
+        let metadata = {
+            requiredFields: [],
+            optionalFields: [],
+            fieldTypes: {},
+            fieldDefaults: {},
+            idFieldType: 'String',
+            idFieldName: 'id',
+            referenceFields: {},
+            relationMetadata: {},
+            foreignKeyMappings: {},
+            foreignKeyTargetFields: {},
+            jsonFields: new Set()
+        };
+        for(let field of modelInfo.fields){
+            this.processFieldMetadata(field, metadata);
+        }
+        if(this.rawModel && this.rawModel.relationTypes){
+            for(let relationName of Object.keys(this.rawModel.relationTypes)){
+                if(sc.hasOwn(metadata.relationMetadata, relationName)){
+                    metadata.relationMetadata[relationName].type = this.rawModel.relationTypes[relationName];
+                }
+            }
+        }
+        return metadata;
+    }
+
+    processFieldMetadata(field, metadata)
+    {
+        metadata.fieldTypes[field.name] = field.type;
+        if('Json' === field.type){
+            metadata.jsonFields.add(field.name);
+        }
+        if(field.isId){
+            metadata.idFieldType = field.type;
+            metadata.idFieldName = field.name;
+        }
+        if(field.hasDefaultValue){
+            metadata.fieldDefaults[field.name] = field.default;
+        }
+        if(field.isRequired && !field.hasDefaultValue && !field.isId && 'object' !== field.kind){
+            metadata.requiredFields.push(field.name);
+        }
+        if(field.isOptional || field.hasDefaultValue){
+            metadata.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){
+                metadata.referenceFields[field.name] = field.type;
+            }
+        }
+        if('object' === field.kind){
+            let relationType = field.isList ? 'many' : 'one';
+            metadata.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)){
+            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++;
+            }
+        }
+    }
+
+    isNumericFieldType(fieldType)
+    {
+        return ('Int' === fieldType || 'BigInt' === fieldType || 'Float' === fieldType || 'Decimal' === fieldType);
+    }
+
+}
+
+module.exports.PrismaMetadataLoader = PrismaMetadataLoader;

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

@@ -0,0 +1,267 @@
+/**
+ *
+ * Reldens - PrismaRelationResolver
+ *
+ */
+
+const { sc } = require('@reldens/utils');
+
+class PrismaRelationResolver
+{
+
+    constructor(props)
+    {
+        this.relationMetadata = sc.get(props, 'relationMetadata', {});
+        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.foreignKeyMappings = sc.get(metadata, 'foreignKeyMappings', this.foreignKeyMappings);
+        this.foreignKeyTargetFields = sc.get(metadata, 'foreignKeyTargetFields', this.foreignKeyTargetFields);
+    }
+
+    setCurrentModelMappings(mappings)
+    {
+        this.currentModelMappings = mappings || {};
+        this.reverseModelMappings = this.buildReverseMappings(this.currentModelMappings);
+    }
+
+    buildReverseMappings(mappings)
+    {
+        let reverse = {};
+        for(let reldensName of Object.keys(mappings)){
+            let prismaName = mappings[reldensName];
+            reverse[prismaName] = reldensName;
+        }
+        return reverse;
+    }
+
+    getAllRelations()
+    {
+        return Object.keys(this.relationMetadata || {});
+    }
+
+    mapToPrismaName(reldensName, modelName)
+    {
+        if(!modelName){
+            if(sc.hasOwn(this.relationMetadata, reldensName)){
+                return reldensName;
+            }
+            if(sc.hasOwn(this.currentModelMappings, reldensName)){
+                return this.currentModelMappings[reldensName];
+            }
+            return null;
+        }
+        let modelMappings = sc.get(this.allRelationMappings, modelName.toLowerCase(), {});
+        if(sc.hasOwn(modelMappings, reldensName)){
+            return modelMappings[reldensName];
+        }
+        return null;
+    }
+
+    mapToReldensName(prismaName)
+    {
+        if(sc.hasOwn(this.reverseModelMappings, prismaName)){
+            return this.reverseModelMappings[prismaName];
+        }
+        return prismaName;
+    }
+
+    getRelatedModelName(prismaName, fromModelName)
+    {
+        if(!fromModelName){
+            let meta = sc.get(this.relationMetadata, prismaName, null);
+            if(meta){
+                return meta.model;
+            }
+            return null;
+        }
+        if(!this.metadataLoader){
+            return null;
+        }
+        let dmmf = this.metadataLoader.getDmmf();
+        if(!dmmf){
+            return null;
+        }
+        let modelInfo = this.findModelInDmmf(dmmf, fromModelName);
+        if(!modelInfo){
+            return null;
+        }
+        for(let field of modelInfo.fields){
+            if(field.name === prismaName && 'object' === field.kind){
+                return field.type;
+            }
+        }
+        return null;
+    }
+
+    findModelInDmmf(dmmf, modelName)
+    {
+        let lowerName = modelName.toLowerCase();
+        if(sc.hasOwn(dmmf.models, lowerName)){
+            return dmmf.models[lowerName];
+        }
+        if(sc.isArray(dmmf.models)){
+            for(let model of dmmf.models){
+                if(model.name.toLowerCase() === lowerName){
+                    return model;
+                }
+            }
+        }
+        return null;
+    }
+
+    convertForeignKeysToRelations(params, isCreate = false)
+    {
+        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}
+            };
+        }
+        return {...data, ...relations};
+    }
+
+    buildIncludeObjectWithMapping(relations)
+    {
+        let include = {};
+        let mapping = {};
+        for(let relation of relations){
+            this.processRelationPath(relation, include, mapping);
+        }
+        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;
+        }
+    }
+
+    transformRelationResults(result, includeConfig, relationMapping)
+    {
+        if(!result || !includeConfig){
+            return result;
+        }
+        if(sc.isArray(result)){
+            return result.map(item => this.transformSingleResult(item, includeConfig, relationMapping));
+        }
+        return this.transformSingleResult(result, includeConfig, relationMapping);
+    }
+
+    transformSingleResult(item, includeConfig, relationMapping)
+    {
+        if(!item || !sc.isObject(item)){
+            return item;
+        }
+        let transformed = {...item};
+        for(let prismaName of Object.keys(includeConfig)){
+            if(!sc.hasOwn(transformed, prismaName)){
+                continue;
+            }
+            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;
+            }
+            if(!sc.hasOwn(params, relation)){
+                continue;
+            }
+            let relationData = params[relation];
+            if(!this.typeCaster){
+                createData[prismaName] = sc.isArray(relationData)
+                    ? {connect: relationData.map(item => ({id: item.id}))}
+                    : {connect: {id: relationData.id}};
+                continue;
+            }
+            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 createData;
+    }
+
+}
+
+module.exports.PrismaRelationResolver = PrismaRelationResolver;