@reldens/storage 0.80.0 → 0.81.0

package/lib/entities-generator.js

@@ -385,7 +385,7 @@ class EntitiesGenerator
             if(!this.prismaClient && this.server.prisma){
                 this.prismaClient = this.server.prisma;
             }
-            Logger.debug('Extract Prisma relations metadata.');
+            //Logger.debug('Extract Prisma relations metadata.');
             this.extractPrismaRelationsMetadata();
         }
         let tables = await this.server.fetchEntitiesFromDatabase();

package/lib/prisma/prisma-driver.js

@@ -5,8 +5,10 @@
  */
 
 const { BaseDriver } = require('../base-driver');
+const { PrismaTypeCaster } = require('./prisma-type-caster');
+const { PrismaMetadataLoader } = require('./prisma-metadata-loader');
+const { PrismaRelationResolver } = require('./prisma-relation-resolver');
 const { Logger, sc } = require('@reldens/utils');
-const { Prisma } = require('@prisma/client');
 
 class PrismaDriver extends BaseDriver
 {
@@ -24,325 +26,59 @@ class PrismaDriver extends BaseDriver
         }
         this.prisma = props.prisma;
         this.model = props.model;
-        this.requiredFields = [];
-        this.optionalFields = [];
-        this.fieldTypes = {};
-        this.fieldDefaults = {};
-        this.idFieldType = 'String';
-        this.referenceFields = {};
-        this.relationMetadata = {};
-        this.foreignKeyMappings = {};
-        this.jsonFields = new Set();
+        this.initHelpers();
         this.initModelMetadata();
     }
 
-    initModelMetadata()
-    {
-        let dmmf = this.getDmmf();
-        if(!dmmf){
-            Logger.warning('Could not access Prisma DMMF metadata');
-            return;
-        }
-        let modelName = this.tableName().toLowerCase();
-        let modelInfo = dmmf.models?.[modelName] || dmmf.models?.find(m => m.name.toLowerCase() === modelName);
-        if(!modelInfo){
-            Logger.warning('Could not find model info for: '+modelName);
-            return;
-        }
-        for(let field of modelInfo.fields){
-            this.processFieldMetadata(field);
-        }
-        if(this.rawModel && this.rawModel.relationTypes){
-            for(let relationName of Object.keys(this.rawModel.relationTypes)){
-                if(sc.hasOwn(this.relationMetadata, relationName)){
-                    this.relationMetadata[relationName].type = this.rawModel.relationTypes[relationName];
-                }
-            }
-        }
-    }
-
-    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;
-        }
-    }
-
-    processFieldMetadata(field)
-    {
-        this.fieldTypes[field.name] = field.type;
-        if('Json' === field.type){
-            this.jsonFields.add(field.name);
-        }
-        if(field.isId){
-            this.idFieldType = field.type;
-        }
-        if(field.hasDefaultValue){
-            this.fieldDefaults[field.name] = field.default;
-        }
-        if(field.isRequired && !field.hasDefaultValue && !field.isId && 'object' !== field.kind){
-            this.requiredFields.push(field.name);
-        }
-        if(field.isOptional || field.hasDefaultValue){
-            this.optionalFields.push(field.name);
-        }
-        if(field.kind === 'scalar' && field.isList === false){
-            let isNumericType = this.isNumericFieldType(field.type);
-            let isReferenceField = field.relationFromFields && 0 < field.relationFromFields.length;
-            if(isNumericType || isReferenceField){
-                this.referenceFields[field.name] = field.type;
-            }
-        }
-        if('object' === field.kind){
-            let relationType = field.isList ? 'many' : 'one';
-            this.relationMetadata[field.name] = {
-                type: relationType,
-                model: field.type,
-                isList: field.isList,
-                isOptional: field.isOptional
-            };
-        }
-        if('object' === field.kind && sc.hasOwn(field, 'relationFromFields') && sc.isArray(field.relationFromFields)){
-            for(let foreignKeyField of field.relationFromFields){
-                this.foreignKeyMappings[foreignKeyField] = field.name;
-            }
-        }
-    }
-
-    getAllRelations()
-    {
-        return Object.keys(this.relationMetadata || {});
-    }
-
-    normalizeRelationName(relationName)
-    {
-        if(sc.hasOwn(this.relationMetadata, relationName)){
-            return relationName;
-        }
-        if(relationName.startsWith('related_')){
-            let withoutPrefix = relationName.substring(8);
-            if(sc.hasOwn(this.relationMetadata, withoutPrefix)){
-                return withoutPrefix;
-            }
-        }
-        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;
-            }
-        }
-        return relationName;
-    }
-
-    isNumericFieldType(fieldType)
-    {
-        return ('Int' === fieldType || 'BigInt' === fieldType || 'Float' === fieldType || 'Decimal' === fieldType);
-    }
-
-    isBooleanFieldType(fieldType)
-    {
-        return 'Boolean' === fieldType;
-    }
-
-    isDateTimeFieldType(fieldType)
-    {
-        return 'DateTime' === fieldType || 'Date' === fieldType;
-    }
-
-    isJsonFieldType(fieldType)
-    {
-        return 'Json' === fieldType;
-    }
-
-    isJsonFieldByName(fieldName)
-    {
-        if(this.jsonFields.has(fieldName)){
-            return true;
-        }
-        if(!this.rawModel || !this.rawModel.properties){
-            return false;
-        }
-        return 'json' === sc.get(this.rawModel.properties[fieldName], 'dbType', '');
-    }
-
-    isStringFieldType(fieldType)
-    {
-        return 'String' === fieldType;
-    }
-
-    castValue(value, fieldType, fieldName = null)
-    {
-        if('id' === fieldName){
-            return this.castToIdType(value);
-        }
-        if(this.isNullOrEmpty(value)){
-            if(sc.hasOwn(this.fieldDefaults, fieldName)){
-                return undefined;
-            }
-            if(-1 !== this.optionalFields.indexOf(fieldName)){
-                return null;
-            }
-            if(-1 !== this.requiredFields.indexOf(fieldName)){
-                Logger.warning('Required field '+fieldName+' cannot be null or empty');
-                return undefined;
-            }
-            return null;
-        }
-        if(this.isJsonFieldByName(fieldName)){
-            return this.castToJsonType(value);
-        }
-        if(this.isNumericFieldType(fieldType)){
-            return this.castToNumericType(value, fieldType);
-        }
-        if(this.isBooleanFieldType(fieldType)){
-            return this.castToBooleanType(value);
-        }
-        if(this.isDateTimeFieldType(fieldType)){
-            return this.castToDateType(value);
-        }
-        if(this.isStringFieldType(fieldType)){
-            return this.castToStringType(value);
-        }
-        return value;
-    }
-
-    isNullOrEmpty(value)
-    {
-        return null === value || undefined === value || '' === value;
-    }
-
-    castToIdType(value)
-    {
-        if(this.isNullOrEmpty(value)){
-            return value;
-        }
-        if(this.isNumericFieldType(this.idFieldType)){
-            let numeric = Number(value);
-            if(!isNaN(numeric)){
-                return ('Int' === this.idFieldType || 'BigInt' === this.idFieldType) ? Math.floor(numeric) : numeric;
-            }
-        }
-        return String(value);
-    }
-
-    castToNumericType(value, fieldType)
-    {
-        if(this.isNullOrEmpty(value)){
-            return null;
-        }
-        let numericValue = Number(value);
-        if(isNaN(numericValue)){
-            Logger.warning('Cannot convert value to numeric: '+value);
-            return null;
-        }
-        if('Int' === fieldType || 'BigInt' === fieldType){
-            return Math.floor(numericValue);
-        }
-        return numericValue;
-    }
-
-    castToBooleanType(value)
-    {
-        if(this.isNullOrEmpty(value)){
-            return null;
-        }
-        if('boolean' === typeof value){
-            return value;
-        }
-        if('number' === typeof value){
-            return 0 !== value;
-        }
-        if('string' === typeof value){
-            let lowerValue = value.toLowerCase();
-            if('true' === lowerValue || '1' === lowerValue || 'yes' === lowerValue){
-                return true;
-            }
-            if('false' === lowerValue || '0' === lowerValue || 'no' === lowerValue){
-                return false;
-            }
-        }
-        return Boolean(value);
+    initHelpers()
+    {
+        this.metadataLoader = new PrismaMetadataLoader({
+            prisma: this.prisma,
+            rawModel: this.rawModel
+        });
+        this.typeCaster = new PrismaTypeCaster({
+            idFieldType: 'String',
+            jsonFields: new Set(),
+            fieldTypes: {},
+            fieldDefaults: {},
+            requiredFields: [],
+            optionalFields: [],
+            rawModel: this.rawModel
+        });
+        this.relationResolver = new PrismaRelationResolver({
+            relationMetadata: {},
+            relationAliases: {},
+            metadataLoader: this.metadataLoader
+        });
     }
 
-    castToDateType(dateValue)
-    {
-        if(dateValue instanceof Date){
-            return dateValue;
-        }
-        if(this.isNullOrEmpty(dateValue)){
-            return null;
-        }
-        let dateString = String(dateValue);
-        if(dateString.match(/^\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}$/)){
-            return new Date(dateString.replace(' ', 'T') + 'Z');
-        }
-        if(dateString.match(/^\d{4}-\d{2}-\d{2}$/)){
-            return new Date(dateString + 'T00:00:00Z');
-        }
-        try {
-            let parsedDate = new Date(dateString);
-            if(isNaN(parsedDate.getTime())){
-                Logger.warning('Invalid date value: '+dateString);
-                return null;
-            }
-            return parsedDate;
-        } catch(error) {
-            Logger.warning('Failed to convert date value: '+dateString);
-            return null;
-        }
-    }
-
-    castToJsonType(value)
-    {
-        if(this.isNullOrEmpty(value)){
-            return Prisma.DbNull;
-        }
-        if('object' === typeof value){
-            return value;
-        }
-        if('string' === typeof value){
-            if(value.startsWith('%') && value.endsWith('%')){
-                return value;
-            }
-            try {
-                return JSON.parse(value);
-            } catch(error) {
-                return value;
-            }
-        }
-        return value;
-    }
-
-    castToStringType(value)
+    initModelMetadata()
     {
-        if(null === value || undefined === value){
-            return null;
-        }
-        if('string' === typeof value){
-            if('null' === value){
-                return null;
-            }
-            return value;
+        let metadata = this.metadataLoader.loadModelMetadata(this.tableName());
+        if(!metadata){
+            return;
         }
-        return String(value);
+        this.requiredFields = metadata.requiredFields;
+        this.optionalFields = metadata.optionalFields;
+        this.fieldTypes = metadata.fieldTypes;
+        this.fieldDefaults = metadata.fieldDefaults;
+        this.idFieldType = metadata.idFieldType;
+        this.referenceFields = metadata.referenceFields;
+        this.relationMetadata = metadata.relationMetadata;
+        this.foreignKeyMappings = metadata.foreignKeyMappings;
+        this.jsonFields = metadata.jsonFields;
+        this.typeCaster.updateMetadata({
+            idFieldType: this.idFieldType,
+            jsonFields: this.jsonFields,
+            fieldTypes: this.fieldTypes,
+            fieldDefaults: this.fieldDefaults,
+            requiredFields: this.requiredFields,
+            optionalFields: this.optionalFields
+        });
+        this.relationResolver.updateMetadata({
+            relationMetadata: this.relationMetadata
+        });
+        this.relationAliases = this.relationResolver.buildRelationAliases(this.tableName());
     }
 
     databaseName()
@@ -370,6 +106,11 @@ class PrismaDriver extends BaseDriver
         return this.rawModel[propertyName] || null;
     }
 
+    getAllRelations()
+    {
+        return this.relationResolver.getAllRelations();
+    }
+
     prepareData(params)
     {
         let data = {};
@@ -379,7 +120,7 @@ class PrismaDriver extends BaseDriver
                 data[key] = params[key];
                 continue;
             }
-            let castedValue = this.castValue(params[key], fieldType, key);
+            let castedValue = this.typeCaster.castValue(params[key], fieldType, key);
             if(undefined !== castedValue){
                 data[key] = castedValue;
             }
@@ -395,9 +136,9 @@ class PrismaDriver extends BaseDriver
             if(sc.hasOwn(this.foreignKeyMappings, key)){
                 let relationName = this.foreignKeyMappings[key];
                 let value = params[key];
-                if(!this.isNullOrEmpty(value)){
+                if(!this.typeCaster.isNullOrEmpty(value)){
                     relations[relationName] = {
-                        connect: {id: this.castToIdType(value)}
+                        connect: {id: this.typeCaster.castToIdType(value)}
                     };
                     continue;
                 }
@@ -410,14 +151,14 @@ class PrismaDriver extends BaseDriver
             }
             let fieldType = this.fieldTypes[key];
             if(!fieldType){
-                if(!this.isNullOrEmpty(params[key])){
+                if(!this.typeCaster.isNullOrEmpty(params[key])){
                     data[key] = params[key];
                 }
                 continue;
             }
-            let castedValue = this.castValue(params[key], fieldType, key);
+            let castedValue = this.typeCaster.castValue(params[key], fieldType, key);
             if(undefined !== castedValue){
-                if(this.isJsonFieldType(fieldType) && null === castedValue){
+                if(this.typeCaster.isJsonFieldType(fieldType) && null === castedValue){
                     continue;
                 }
                 data[key] = castedValue;
@@ -470,64 +211,69 @@ class PrismaDriver extends BaseDriver
     {
         if(sc.isArray(value)){
             if('id' === key){
-                return value.map(id => this.castToIdType(id));
+                return value.map(id => this.typeCaster.castToIdType(id)).filter(id => null !== id);
             }
             let fieldType = this.fieldTypes[key];
             if(fieldType){
-                return value.map(val => this.castValue(val, fieldType, key)).filter(val => undefined !== val);
+                return value.map(val => this.typeCaster.castValue(val, fieldType, key)).filter(val => undefined !== val);
             }
             return value;
         }
         if('id' === key){
-            return this.castToIdType(value);
+            return this.typeCaster.castToIdType(value);
         }
         let fieldType = this.fieldTypes[key];
         if(fieldType){
-            let castedValue = this.castValue(value, fieldType, key);
+            let castedValue = this.typeCaster.castValue(value, fieldType, key);
             return undefined !== castedValue ? castedValue : value;
         }
         return value;
     }
 
-    transformRelationResults(result, includeConfig, relationMapping)
+    applyOperator(value, operator, fieldName = null)
     {
-        if(!result || !includeConfig){
-            return result;
-        }
-        if(sc.isArray(result)){
-            return result.map(item => this.transformSingleResult(item, includeConfig, relationMapping));
+        let upperOperator = operator ? operator.toUpperCase() : '';
+        if('LIKE' === upperOperator){
+            return this.handleLikeOperator(value, fieldName);
         }
-        return this.transformSingleResult(result, includeConfig, relationMapping);
+        let operatorsMap = {
+            '=': value,
+            '!=': {not: value},
+            '>': {gt: value},
+            '>=': {gte: value},
+            '<': {lt: value},
+            '<=': {lte: value},
+            'IN': {in: value},
+            'NOT IN': {notIn: value}
+        };
+        return operatorsMap[upperOperator] || value;
     }
 
-    transformSingleResult(item, includeConfig, relationMapping)
+    handleLikeOperator(value, fieldName)
     {
-        if(!item || !sc.isObject(item)){
-            return item;
+        let cleanValue = String(value).replace(/%/g, '');
+        if(this.typeCaster.isJsonFieldByName(fieldName) || this.isJsonField(fieldName)){
+            return this.handleJsonTextSearch(cleanValue);
         }
-        let transformed = {...item};
-        for(let relationName of Object.keys(includeConfig)){
-            if(!sc.hasOwn(transformed, relationName)){
-                continue;
-            }
-            let relationMeta = this.relationMetadata[relationName];
-            if(!relationMeta){
-                continue;
-            }
-            let relationValue = transformed[relationName];
-            if('one' === relationMeta.type && sc.isArray(relationValue)){
-                relationValue = 0 < relationValue.length ? [...relationValue].shift() : null;
-            }
-            if('many' === relationMeta.type && !sc.isArray(relationValue)){
-                relationValue = relationValue ? [relationValue] : [];
-            }
-            let originalName = sc.get(relationMapping, relationName, relationName);
-            transformed[originalName] = relationValue;
-            if(originalName !== relationName){
-                delete transformed[relationName];
+        if('id' === fieldName || sc.hasOwn(this.referenceFields, fieldName)){
+            let numericValue = Number(cleanValue);
+            if(!isNaN(numericValue)){
+                return numericValue;
             }
         }
-        return transformed;
+        return {contains: cleanValue};
+    }
+
+    handleJsonTextSearch(searchValue)
+    {
+        return {
+            string_contains: searchValue
+        };
+    }
+
+    isJsonField(fieldName)
+    {
+        return this.jsonFields && this.jsonFields.has(fieldName);
     }
 
     async create(params)
@@ -553,26 +299,30 @@ class PrismaDriver extends BaseDriver
         this.ensureRequiredFields(preparedData);
         let createData = {data: preparedData};
         if(0 < relations.length){
-            let includeData = this.buildIncludeObjectWithMapping(relations);
+            let includeData = this.relationResolver.buildIncludeObjectWithMapping(relations);
             createData.include = includeData.include;
             for(let relation of relations){
-                let normalizedRelation = this.normalizeRelationName(relation);
+                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.castToIdType(item.id)}))
+                        connect: relationData.map(item => ({id: this.typeCaster.castToIdType(item.id)}))
                     };
                     continue;
                 }
                 createData.data[normalizedRelation] = {
-                    connect: {id: this.castToIdType(relationData.id)}
+                    connect: {id: this.typeCaster.castToIdType(relationData.id)}
                 };
             }
             try {
-                return this.transformRelationResults(await this.model.create(createData), includeData.include, includeData.mapping);
+                return this.relationResolver.transformRelationResults(
+                    await this.model.create(createData),
+                    includeData.include,
+                    includeData.mapping
+                );
             } catch(error) {
                 Logger.error('Create with relations error: '+error.message);
                 return false;
@@ -618,7 +368,7 @@ class PrismaDriver extends BaseDriver
 
     async updateById(id, params)
     {
-        let castedId = this.castToIdType(id);
+        let castedId = this.typeCaster.castToIdType(id);
         let found = await this.loadById(castedId);
         if(!found){
             return false;
@@ -640,7 +390,7 @@ class PrismaDriver extends BaseDriver
         let preparedData = this.prepareDataWithRelations(params);
         let existing = false;
         if(params.id){
-            let castedId = this.castToIdType(params.id);
+            let castedId = this.typeCaster.castToIdType(params.id);
             existing = await this.loadById(castedId);
             if(existing){
                 let patch = Object.assign({}, preparedData);
@@ -661,7 +411,7 @@ class PrismaDriver extends BaseDriver
             if(existing){
                 try {
                     return await this.model.update({
-                        where: {id: this.castToIdType(existing.id)},
+                        where: {id: this.typeCaster.castToIdType(existing.id)},
                         data: preparedData
                     });
                 } catch(error) {
@@ -688,7 +438,7 @@ class PrismaDriver extends BaseDriver
 
     async deleteById(id)
     {
-        let castedId = this.castToIdType(id);
+        let castedId = this.typeCaster.castToIdType(id);
         let found = await this.loadById(castedId);
         if(!found){
             return false;
@@ -726,7 +476,7 @@ class PrismaDriver extends BaseDriver
             where: processedFilters
         };
         if(0 < relations.length){
-            query.include = this.buildIncludeObjectWithMapping(relations).include;
+            query.include = this.relationResolver.buildIncludeObjectWithMapping(relations).include;
         }
         try {
             return await this.model.count(query);
@@ -811,7 +561,7 @@ class PrismaDriver extends BaseDriver
 
     async loadById(id)
     {
-        let castedId = this.castToIdType(id);
+        let castedId = this.typeCaster.castToIdType(id);
         try {
             return await this.model.findUnique({
                 where: {id: castedId}
@@ -826,7 +576,7 @@ class PrismaDriver extends BaseDriver
     {
         return this.executeQueryWithRelations(
             (q) => this.model.findUnique(q),
-            {where: {id: this.castToIdType(id)}},
+            {where: {id: this.typeCaster.castToIdType(id)}},
             relations,
             'Load by ID with relations error: ',
             null
@@ -835,7 +585,10 @@ class PrismaDriver extends BaseDriver
 
     async loadByIds(ids)
     {
-        let castedIds = ids.map(id => this.castToIdType(id));
+        let castedIds = ids.map(id => this.typeCaster.castToIdType(id)).filter(id => null !== id);
+        if(0 === castedIds.length){
+            return [];
+        }
         try {
             return await this.model.findMany({
                 where: {
@@ -935,82 +688,23 @@ class PrismaDriver extends BaseDriver
         return this.processFilters(filter);
     }
 
-    applyOperator(value, operator, fieldName = null)
-    {
-        let upperOperator = operator ? operator.toUpperCase() : '';
-        if('LIKE' === upperOperator){
-            return this.handleLikeOperator(value, fieldName);
-        }
-        let operatorsMap = {
-            '=': value,
-            '!=': {not: value},
-            '>': {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.isJsonFieldByName(fieldName) || this.isJsonField(fieldName)){
-            return this.handleJsonTextSearch(cleanValue);
-        }
-        if('id' === fieldName || sc.hasOwn(this.referenceFields, fieldName)){
-            let numericValue = Number(cleanValue);
-            if(!isNaN(numericValue)){
-                return numericValue;
-            }
-        }
-        return {contains: cleanValue};
-    }
-
-    handleJsonTextSearch(searchValue)
-    {
-        return {
-            string_contains: searchValue
-        };
-    }
-
     async executeQueryWithRelations(modelMethod, query, relations, errorMessage, defaultReturn)
     {
         if(!sc.isArray(relations) || 0 === relations.length){
             relations = this.getAllRelations();
         }
-        let includeData = this.buildIncludeObjectWithMapping(relations);
+        let includeData = this.relationResolver.buildIncludeObjectWithMapping(relations);
         if(0 < Object.keys(includeData.include).length){
             query.include = includeData.include;
         }
         try {
-            return this.transformRelationResults(await modelMethod(query), includeData.include, includeData.mapping);
+            return this.relationResolver.transformRelationResults(await modelMethod(query), includeData.include, includeData.mapping);
         } catch(error) {
             Logger.error(errorMessage+error.message);
             return defaultReturn;
         }
     }
 
-    buildIncludeObjectWithMapping(relations)
-    {
-        let include = {};
-        let mapping = {};
-        for(let relation of relations){
-            let normalizedRelation = this.normalizeRelationName(relation);
-            if(!sc.hasOwn(this.relationMetadata, normalizedRelation)){
-                //Logger.debug('Relation "'+relation+'" (normalized: "'+normalizedRelation+'") not found in model '+this.tableName());
-                continue;
-            }
-            include[normalizedRelation] = true;
-            if(relation !== normalizedRelation){
-                mapping[normalizedRelation] = relation;
-            }
-        }
-        return {include, mapping};
-    }
-
 }
 
 module.exports.PrismaDriver = PrismaDriver;

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

@@ -0,0 +1,126 @@
+/**
+ *
+ * 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',
+            referenceFields: {},
+            relationMetadata: {},
+            foreignKeyMappings: {},
+            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;
+        }
+        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)){
+            for(let foreignKeyField of field.relationFromFields){
+                metadata.foreignKeyMappings[foreignKeyField] = field.name;
+            }
+        }
+    }
+
+    isNumericFieldType(fieldType)
+    {
+        return ('Int' === fieldType || 'BigInt' === fieldType || 'Float' === fieldType || 'Decimal' === fieldType);
+    }
+
+}
+
+module.exports.PrismaMetadataLoader = PrismaMetadataLoader;

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.relationAliases = sc.get(props, 'relationAliases', {});
+        this.metadataLoader = sc.get(props, 'metadataLoader', null);
+    }
+
+    updateMetadata(metadata)
+    {
+        this.relationMetadata = sc.get(metadata, 'relationMetadata', this.relationMetadata);
+        this.relationAliases = sc.get(metadata, 'relationAliases', this.relationAliases);
+    }
+
+    buildRelationAliases(tableName)
+    {
+        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;
+    }
+
+    generateRelationAliases(prismaRelation, relatedModel, tableName)
+    {
+        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);
+        }
+        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;
+    }
+
+    getAllRelations()
+    {
+        return Object.keys(this.relationMetadata || {});
+    }
+
+    normalizeRelationName(relationName)
+    {
+        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(sc.hasOwn(this.relationAliases, withoutPrefix)){
+                return this.relationAliases[withoutPrefix];
+            }
+        }
+        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;
+            }
+        }
+        return relationName;
+    }
+
+    buildIncludeObjectWithMapping(relations)
+    {
+        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;
+            }
+        }
+        return {include, mapping};
+    }
+
+    buildNestedInclude(relationPath, include, mapping)
+    {
+        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;
+        }
+        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;
+        }
+        let dmmf = this.metadataLoader.getDmmf();
+        if(!dmmf){
+            return;
+        }
+        let modelInfo = dmmf.models?.[modelName.toLowerCase()]
+            || dmmf.models?.find(m => m.name.toLowerCase() === modelName.toLowerCase());
+        if(!modelInfo){
+            return;
+        }
+        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
+                };
+            }
+        }
+        let parts = relationPath.split('.');
+        let currentPart = parts.shift();
+        let normalizedPart = this.normalizeNestedRelation(currentPart, relationFields, tableName);
+        if(!normalizedPart){
+            return;
+        }
+        if(0 === parts.length){
+            include[normalizedPart] = true;
+            if(currentPart !== normalizedPart){
+                mapping[normalizedPart] = currentPart;
+            }
+            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);
+    }
+
+    normalizeNestedRelation(relationName, relationFields, tableName)
+    {
+        if(sc.hasOwn(relationFields, relationName)){
+            return relationName;
+        }
+        let cleanName = relationName.replace('related_', '');
+        if(sc.hasOwn(relationFields, cleanName)){
+            return cleanName;
+        }
+        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 null;
+    }
+
+    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 relationName of Object.keys(includeConfig)){
+            if(!sc.hasOwn(transformed, relationName)){
+                continue;
+            }
+            let relationMeta = this.relationMetadata[relationName];
+            if(!relationMeta){
+                continue;
+            }
+            let relationValue = transformed[relationName];
+            if('one' === relationMeta.type && sc.isArray(relationValue)){
+                relationValue = 0 < relationValue.length ? [...relationValue].shift() : null;
+            }
+            if('many' === relationMeta.type && !sc.isArray(relationValue)){
+                relationValue = relationValue ? [relationValue] : [];
+            }
+            let originalName = sc.get(relationMapping, relationName, relationName);
+            transformed[originalName] = relationValue;
+            if(originalName !== relationName){
+                delete transformed[relationName];
+            }
+        }
+        return transformed;
+    }
+
+}
+
+module.exports.PrismaRelationResolver = PrismaRelationResolver;

package/lib/prisma/prisma-type-caster.js

@@ -0,0 +1,231 @@
+/**
+ *
+ * Reldens - PrismaTypeCaster
+ *
+ */
+
+const { Logger, sc } = require('@reldens/utils');
+const { Prisma } = require('@prisma/client');
+
+class PrismaTypeCaster
+{
+
+    constructor(props)
+    {
+        this.idFieldType = sc.get(props, 'idFieldType', 'String');
+        this.jsonFields = sc.get(props, 'jsonFields', new Set());
+        this.fieldTypes = sc.get(props, 'fieldTypes', {});
+        this.fieldDefaults = sc.get(props, 'fieldDefaults', {});
+        this.requiredFields = sc.get(props, 'requiredFields', []);
+        this.optionalFields = sc.get(props, 'optionalFields', []);
+        this.rawModel = sc.get(props, 'rawModel', false);
+    }
+
+    updateMetadata(metadata)
+    {
+        this.idFieldType = sc.get(metadata, 'idFieldType', this.idFieldType);
+        this.jsonFields = sc.get(metadata, 'jsonFields', this.jsonFields);
+        this.fieldTypes = sc.get(metadata, 'fieldTypes', this.fieldTypes);
+        this.fieldDefaults = sc.get(metadata, 'fieldDefaults', this.fieldDefaults);
+        this.requiredFields = sc.get(metadata, 'requiredFields', this.requiredFields);
+        this.optionalFields = sc.get(metadata, 'optionalFields', this.optionalFields);
+    }
+
+    isNumericFieldType(fieldType)
+    {
+        return ('Int' === fieldType || 'BigInt' === fieldType || 'Float' === fieldType || 'Decimal' === fieldType);
+    }
+
+    isBooleanFieldType(fieldType)
+    {
+        return 'Boolean' === fieldType;
+    }
+
+    isDateTimeFieldType(fieldType)
+    {
+        return 'DateTime' === fieldType || 'Date' === fieldType;
+    }
+
+    isJsonFieldType(fieldType)
+    {
+        return 'Json' === fieldType;
+    }
+
+    isJsonFieldByName(fieldName)
+    {
+        if(this.jsonFields.has(fieldName)){
+            return true;
+        }
+        if(!this.rawModel || !this.rawModel.properties){
+            return false;
+        }
+        return 'json' === sc.get(this.rawModel.properties[fieldName], 'dbType', '');
+    }
+
+    isStringFieldType(fieldType)
+    {
+        return 'String' === fieldType;
+    }
+
+    isNullOrEmpty(value)
+    {
+        return null === value || undefined === value || '' === value;
+    }
+
+    castValue(value, fieldType, fieldName = null)
+    {
+        if('id' === fieldName){
+            return this.castToIdType(value);
+        }
+        if(this.isNullOrEmpty(value)){
+            if(sc.hasOwn(this.fieldDefaults, fieldName)){
+                return undefined;
+            }
+            if(-1 !== this.optionalFields.indexOf(fieldName)){
+                return null;
+            }
+            if(-1 !== this.requiredFields.indexOf(fieldName)){
+                Logger.warning('Required field '+fieldName+' cannot be null or empty');
+                return undefined;
+            }
+            return null;
+        }
+        if(this.isJsonFieldByName(fieldName)){
+            return this.castToJsonType(value);
+        }
+        if(this.isNumericFieldType(fieldType)){
+            return this.castToNumericType(value, fieldType);
+        }
+        if(this.isBooleanFieldType(fieldType)){
+            return this.castToBooleanType(value);
+        }
+        if(this.isDateTimeFieldType(fieldType)){
+            return this.castToDateType(value);
+        }
+        if(this.isStringFieldType(fieldType)){
+            return this.castToStringType(value);
+        }
+        return value;
+    }
+
+    castToIdType(value)
+    {
+        if(this.isNullOrEmpty(value)){
+            return value;
+        }
+        if(this.isNumericFieldType(this.idFieldType)){
+            let numeric = Number(value);
+            if(!isNaN(numeric)){
+                return ('Int' === this.idFieldType || 'BigInt' === this.idFieldType) ? Math.floor(numeric) : numeric;
+            }
+            Logger.warning('Cannot cast non-numeric value "'+value+'" to ID type '+this.idFieldType);
+            return null;
+        }
+        return String(value);
+    }
+
+    castToNumericType(value, fieldType)
+    {
+        if(this.isNullOrEmpty(value)){
+            return null;
+        }
+        let numericValue = Number(value);
+        if(isNaN(numericValue)){
+            Logger.warning('Cannot convert value to numeric: '+value);
+            return null;
+        }
+        if('Int' === fieldType || 'BigInt' === fieldType){
+            return Math.floor(numericValue);
+        }
+        return numericValue;
+    }
+
+    castToBooleanType(value)
+    {
+        if(this.isNullOrEmpty(value)){
+            return null;
+        }
+        if('boolean' === typeof value){
+            return value;
+        }
+        if('number' === typeof value){
+            return 0 !== value;
+        }
+        if('string' === typeof value){
+            let lowerValue = value.toLowerCase();
+            if('true' === lowerValue || '1' === lowerValue || 'yes' === lowerValue){
+                return true;
+            }
+            if('false' === lowerValue || '0' === lowerValue || 'no' === lowerValue){
+                return false;
+            }
+        }
+        return Boolean(value);
+    }
+
+    castToDateType(dateValue)
+    {
+        if(dateValue instanceof Date){
+            return dateValue;
+        }
+        if(this.isNullOrEmpty(dateValue)){
+            return null;
+        }
+        let dateString = String(dateValue);
+        if(dateString.match(/^\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}$/)){
+            return new Date(dateString.replace(' ', 'T')+'Z');
+        }
+        if(dateString.match(/^\d{4}-\d{2}-\d{2}$/)){
+            return new Date(dateString+'T00:00:00Z');
+        }
+        try {
+            let parsedDate = new Date(dateString);
+            if(isNaN(parsedDate.getTime())){
+                Logger.warning('Invalid date value: '+dateString);
+                return null;
+            }
+            return parsedDate;
+        } catch(error) {
+            Logger.warning('Failed to convert date value: '+dateString);
+            return null;
+        }
+    }
+
+    castToJsonType(value)
+    {
+        if(this.isNullOrEmpty(value)){
+            return Prisma.DbNull;
+        }
+        if('object' === typeof value){
+            return value;
+        }
+        if('string' === typeof value){
+            if(value.startsWith('%') && value.endsWith('%')){
+                return value;
+            }
+            try {
+                return JSON.parse(value);
+            } catch(error) {
+                return value;
+            }
+        }
+        return value;
+    }
+
+    castToStringType(value)
+    {
+        if(null === value || undefined === value){
+            return null;
+        }
+        if('string' === typeof value){
+            if('null' === value){
+                return null;
+            }
+            return value;
+        }
+        return String(value);
+    }
+
+}
+
+module.exports.PrismaTypeCaster = PrismaTypeCaster;

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@reldens/storage",
     "scope": "@reldens",
-    "version": "0.80.0",
+    "version": "0.81.0",
     "description": "Reldens - Storage",
     "author": "Damian A. Pastorini",
     "license": "MIT",