@reldens/storage 0.56.0 → 0.58.0

package/lib/entities-generator.js

@@ -53,6 +53,7 @@ class EntitiesGenerator
         this.existingEntities = {};
         this.existingEntityFields = {};
         this.existingModels = {};
+        this.prismaRelationsMetadata = {};
         this.entitiesGeneration = new EntitiesGeneration({
             entitiesFolder: this.entitiesFolder,
             templatePath: this.templates['entity']
@@ -164,6 +165,125 @@ class EntitiesGenerator
         return false;
     }
 
+    extractPrismaRelationsMetadata()
+    {
+        if(!this.prismaClient){
+            Logger.warning('Missing PrismaClient.');
+            return;
+        }
+        if(!this.server || !(this.server instanceof PrismaDataServer)){
+            Logger.warning('Server is not a PrismaDataServer instance.');
+            return;
+        }
+        try {
+            let dmmf = this.prismaClient._runtimeDataModel || this.prismaClient._dmmf?.datamodel;
+            if(!dmmf || !dmmf.models){
+                Logger.warning('Could not extract Prisma DMMF data for relations metadata.');
+                return;
+            }
+            if(sc.isArray(dmmf.models)){
+                this.processArrayModels(dmmf.models);
+                return;
+            }
+            this.processObjectModels(dmmf.models);
+        } catch(error) {
+            Logger.warning('Failed to extract Prisma relations metadata: ' + error.message);
+        }
+    }
+
+    processArrayModels(models)
+    {
+        for(let model of models){
+            if(!model){
+                Logger.error('Missing model.');
+                continue;
+            }
+            if(!model.name){
+                Logger.error('Missing model name.', model);
+                continue;
+            }
+            if(!sc.isArray(model.fields)){
+                Logger.error('Model fields not an array.', model);
+                continue;
+            }
+            this.processModelForRelations(model.name, model, models);
+        }
+        Logger.info('Extracted relations metadata for ' + Object.keys(this.prismaRelationsMetadata).length + ' models.');
+    }
+
+    processObjectModels(models)
+    {
+        for(let modelName of Object.keys(models)){
+            let model = models[modelName];
+            if(!model){
+                Logger.error('Missing model.');
+                continue;
+            }
+            if(!sc.isArray(model.fields)){
+                Logger.error('Model fields not an array.', model);
+                continue;
+            }
+            this.processModelForRelations(modelName, model, models);
+        }
+        Logger.info('Extracted relations metadata for ' + Object.keys(this.prismaRelationsMetadata).length + ' models.');
+    }
+
+    processModelForRelations(modelName, model, allModels)
+    {
+        let tableName = modelName.toLowerCase();
+        this.prismaRelationsMetadata[tableName] = {};
+        for(let field of model.fields){
+            if('object' !== field.kind){
+                continue;
+            }
+            let relationType = 'many';
+            if(!field.isList){
+                relationType = this.inferRelationType(field, model, allModels, modelName);
+            }
+            this.prismaRelationsMetadata[tableName][field.name] = {
+                type: relationType,
+                model: field.type,
+                isList: field.isList,
+                isOptional: field.isOptional,
+                relationName: field.relationName
+            };
+        }
+    }
+
+    inferRelationType(field, model, allModels, modelName)
+    {
+        if(field.isList){
+            return 'many';
+        }
+        let relatedModel = this.findRelatedModel(allModels, field.type);
+        if(!relatedModel){
+            return 'one';
+        }
+        let backReference = relatedModel.fields.find(f =>
+            'object' === f.kind &&
+            f.type === modelName &&
+            f.relationName === field.relationName
+        );
+        if(!backReference){
+            return 'one';
+        }
+        if(field.relationFromFields && 0 < field.relationFromFields.length){
+            return 'one';
+        }
+        if(backReference.relationFromFields && 0 < backReference.relationFromFields.length){
+            return 'one';
+        }
+        return 'one';
+    }
+
+    findRelatedModel(allModels, fieldType)
+    {
+        if(sc.isArray(allModels)){
+            return allModels.find(m => m.name === fieldType);
+        }
+        return allModels[fieldType];
+    }
+
     filterTablesToGenerate(tables, driverKey)
     {
         let filteredTables = {};
@@ -254,6 +374,18 @@ class EntitiesGenerator
             Logger.critical('Failed to connect to database: '+error.message);
             return false;
         }
+        let driverKey = sc.get(
+            this.connectionData,
+            'driver',
+            (this.server ? sc.get(this.driversClassMap, this.server.constructor.name, false) : false)
+        );
+        if('prisma' === driverKey){
+            if(!this.prismaClient && this.server.prisma){
+                this.prismaClient = this.server.prisma;
+            }
+            Logger.debug('Extract Prisma relations metadata.');
+            this.extractPrismaRelationsMetadata();
+        }
         let tables = await this.server.fetchEntitiesFromDatabase();
         if(!tables){
             Logger.critical('EntitiesGenerator tables fetch failed.');
@@ -264,15 +396,13 @@ class EntitiesGenerator
         }
         this.detectExistingEntities();
         this.detectExistingModels();
-        let driverKey = sc.get(
-            this.connectionData,
-            'driver',
-            (this.server ? sc.get(this.driversClassMap, this.server.constructor.name, false) : false)
-        );
         if(!driverKey){
             Logger.critical('Failed to fetch driver key.');
             return false;
         }
+        if('objection-js' === driverKey){
+            this.modelsGeneration.setAllTablesData(tables);
+        }
         let tablesToGenerate = this.filterTablesToGenerate(tables, driverKey);
         if(0 === Object.keys(tablesToGenerate).length && !this.isOverride){
             return true;
@@ -284,11 +414,13 @@ class EntitiesGenerator
                 continue;
             }
             let entityInfo = this.entitiesGeneration.generatedEntities[tableName];
+            let relationMetadata = sc.get(this.prismaRelationsMetadata, tableName, {});
             let modelGenerated = await this.modelsGeneration.generateModelFile(
                 tableName,
                 tableData,
                 driverKey,
-                entityInfo
+                entityInfo,
+                relationMetadata
             );
             if(modelGenerated){
                 let modelInfo = this.modelsGeneration.generatedModels[tableName];

package/lib/generators/models-generation.js

@@ -18,9 +18,10 @@ class ModelsGeneration extends BaseGenerator
         this.modelsFolder = sc.get(props, 'modelsFolder', '');
         this.templates = sc.get(props, 'templates', {});
         this.generatedModels = {};
+        this.allTablesData = {};
     }
 
-    async generateModelFile(tableName, tableData, driverKey, entityInfo)
+    async generateModelFile(tableName, tableData, driverKey, entityInfo, relationMetadata = {})
     {
         let modelTemplatePath = this.templates[driverKey];
         if(!FileHandler.exists(modelTemplatePath)){
@@ -37,7 +38,7 @@ class ModelsGeneration extends BaseGenerator
         let modelPropertiesConstructor = Object.keys(tableData.columns)
             .map(columnName => 'this.'+columnName+' = '+columnName+';')
             .join('\n        ');
-        let modelRelations = '';
+        let modelRelations = this.generateModelRelations(tableName, tableData, relationMetadata, driverKey);
         let entityPropertiesDefinition = this.getEntityPropertiesDefinition(tableData.columns, driverKey);
         let replacements = {
             modelClassName,
@@ -65,6 +66,147 @@ class ModelsGeneration extends BaseGenerator
         return true;
     }
 
+    setAllTablesData(allTablesData)
+    {
+        this.allTablesData = allTablesData;
+    }
+
+    generateModelRelations(tableName, tableData, relationMetadata, driverKey)
+    {
+        if('prisma' === driverKey){
+            return this.generatePrismaRelations(relationMetadata);
+        }
+        if('objection-js' === driverKey){
+            return this.generateObjectionJsRelations(tableName, tableData);
+        }
+        return '';
+    }
+
+    generatePrismaRelations(relationMetadata)
+    {
+        if(!relationMetadata || 0 === Object.keys(relationMetadata).length){
+            return '';
+        }
+        let relationTypesArray = [];
+        for(let relationName of Object.keys(relationMetadata)){
+            let relation = relationMetadata[relationName];
+            relationTypesArray.push('        '+relationName+': \''+relation.type+'\'');
+        }
+        if(0 === relationTypesArray.length){
+            return '';
+        }
+        return '\n\n    static get relationTypes()\n    {\n        return {\n    '+relationTypesArray.join(',\n    ')+'\n        };\n    }';
+    }
+
+    generateObjectionJsRelations(tableName, tableData)
+    {
+        let relations = this.detectObjectionJsRelations(tableName, tableData);
+        let reverseRelations = this.detectReverseObjectionJsRelations(tableName);
+        let allRelations = Object.assign({}, relations, reverseRelations);
+        if(0 === Object.keys(allRelations).length){
+            return '';
+        }
+        let relationMappings = [];
+        let requiredModels = [];
+        for(let relationKey of Object.keys(allRelations)){
+            let relation = allRelations[relationKey];
+            let tableReference = relation.referencedTable || relation.referencingTable;
+            let relatedModelClass = sc.capitalizedCamelCase(tableReference)+'Model';
+            if(!requiredModels.find(m => m.modelClass === relatedModelClass)){
+                requiredModels.push({
+                    modelClass: relatedModelClass,
+                    fileName: sc.kebabCase(tableReference)+'-model'
+                });
+            }
+            let relationMapping = '            '+relationKey+': {\n';
+            relationMapping += '                relation: this.'+relation.relationType+',\n';
+            relationMapping += '                modelClass: '+relatedModelClass+',\n';
+            relationMapping += '                join: {\n';
+            relationMapping += '                    from: this.tableName+\'.'+relation.fromColumn+'\',\n';
+            relationMapping += '                    to: '+relatedModelClass+'.tableName+\'.'+relation.toColumn+'\'\n';
+            relationMapping += '                }\n';
+            relationMapping += '            }';
+            relationMappings.push(relationMapping);
+        }
+        if(0 === relationMappings.length){
+            return '';
+        }
+        let requireStatements = [];
+        for(let modelInfo of requiredModels){
+            requireStatements.push('        const { '+modelInfo.modelClass+' } = require(\'./'+modelInfo.fileName+'\');');
+        }
+        let relationMappingsMethod = '\n\n    static get relationMappings()\n    {\n';
+        relationMappingsMethod += requireStatements.join('\n')+'\n';
+        relationMappingsMethod += '        return {\n';
+        relationMappingsMethod += relationMappings.join(',\n');
+        relationMappingsMethod += '\n        };\n';
+        relationMappingsMethod += '    }';
+        return relationMappingsMethod;
+    }
+
+    detectObjectionJsRelations(tableName, tableData)
+    {
+        let relations = {};
+        for(let columnName of Object.keys(tableData.columns)){
+            let column = tableData.columns[columnName];
+            if(!sc.hasOwn(column, 'referencedTable')){
+                continue;
+            }
+            let relationKey = 'related_'+column.referencedTable;
+            let relationType = this.determineRelationType(column, true);
+            relations[relationKey] = {
+                fromColumn: columnName,
+                toColumn: column.referencedColumn,
+                referencedTable: column.referencedTable,
+                relationType: relationType
+            };
+        }
+        return relations;
+    }
+
+    detectReverseObjectionJsRelations(tableName)
+    {
+        let reverseRelations = {};
+        for(let otherTableName of Object.keys(this.allTablesData)){
+            if(otherTableName === tableName){
+                continue;
+            }
+            let otherTableData = this.allTablesData[otherTableName];
+            for(let columnName of Object.keys(otherTableData.columns)){
+                let column = otherTableData.columns[columnName];
+                if(!sc.hasOwn(column, 'referencedTable')){
+                    continue;
+                }
+                if(column.referencedTable !== tableName){
+                    continue;
+                }
+                let relationKey = 'related_'+otherTableName;
+                let relationType = this.determineRelationType(column, false);
+                reverseRelations[relationKey] = {
+                    fromColumn: column.referencedColumn,
+                    toColumn: columnName,
+                    referencingTable: otherTableName,
+                    relationType: relationType
+                };
+            }
+        }
+        return reverseRelations;
+    }
+
+    determineRelationType(column, isForwardRelation)
+    {
+        if(isForwardRelation){
+            if('PRI' === column.key){
+                return 'HasOneRelation';
+            }
+            return 'BelongsToOneRelation';
+        }
+        if('PRI' === column.key){
+            return 'HasOneRelation';
+        }
+        return 'HasManyRelation';
+    }
+
     getEntityPropertiesDefinition(columns, driverKey)
     {
         if('mikro-orm' === driverKey){

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

@@ -93,14 +93,14 @@ class PrismaDataServer extends BaseDataServer
                 try {
                     let result = await this.executeStatement(cleanStatement);
                     results.push(result);
-                    Logger.debug('Statement executed, result: ' + JSON.stringify(result));
+                    //Logger.debug('Statement executed, result: ' + JSON.stringify(result));
                 } catch(stmtError) {
                     Logger.error('Statement "'+cleanStatement+'" execution failed: '+stmtError.message);
                     return false;
                 }
             }
             if(0 === results.length){
-                Logger.error('Statement results length is zero.', results);
+                //Logger.error('Statement results length is zero.', results);
                 return false;
             }
             return 1 === results.length ? results[0] : results;

package/lib/prisma/prisma-driver.js

@@ -33,7 +33,9 @@ class PrismaDriver extends BaseDriver
         this.fieldTypes = {};
         this.idFieldType = 'String';
         this.referenceFields = {};
+        this.relationMetadata = {};
         this.initFieldMetadata();
+        this.initRelationMetadata();
     }
 
     initFieldMetadata()
@@ -69,6 +71,44 @@ class PrismaDriver extends BaseDriver
         }
     }
 
+    initRelationMetadata()
+    {
+        try {
+            let dmmf = this.prisma._runtimeDataModel || Prisma.dmmf?.datamodel;
+            if(!dmmf){
+                return;
+            }
+            let modelName = this.tableName().toLowerCase();
+            let modelInfo = dmmf.models?.[modelName] || dmmf.models?.find(m => m.name.toLowerCase() === modelName);
+            if(!modelInfo){
+                return;
+            }
+            for(let field of modelInfo.fields){
+                if('object' === field.kind){
+                    let relationType = 'many';
+                    if(!field.isList){
+                        relationType = 'one';
+                    }
+                    this.relationMetadata[field.name] = {
+                        type: relationType,
+                        model: field.type,
+                        isList: field.isList,
+                        isOptional: field.isOptional
+                    };
+                }
+            }
+            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];
+                    }
+                }
+            }
+        } catch(error) {
+            Logger.warning('Could not initialize relation metadata: '+error.message);
+        }
+    }
+
     castIdValue(id)
     {
         if(null === id || undefined === id){
@@ -211,7 +251,7 @@ class PrismaDriver extends BaseDriver
                 if(sc.hasOwn(this.referenceFields, key) && !sc.isArray(operatorValue)){
                     operatorValue = this.castNumericValue(operatorValue, this.referenceFields[key]);
                 }
-                processedFilters[key] = this.applyOperator(operatorValue, value.operator);
+                processedFilters[key] = this.applyOperator(operatorValue, value.operator, key);
                 continue;
             }
             if(sc.isObject(value) && !sc.isArray(value)){
@@ -239,6 +279,43 @@ class PrismaDriver extends BaseDriver
         return processedFilters;
     }
 
+    transformRelationResults(result, includeConfig)
+    {
+        if(!result || !includeConfig){
+            return result;
+        }
+        if(sc.isArray(result)){
+            return result.map(item => this.transformSingleResult(item, includeConfig));
+        }
+        return this.transformSingleResult(result, includeConfig);
+    }
+
+    transformSingleResult(item, includeConfig)
+    {
+        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)){
+                transformed[relationName] = 0 < relationValue.length ? relationValue[0] : null;
+                continue;
+            }
+            if('many' === relationMeta.type && !sc.isArray(relationValue)){
+                transformed[relationName] = relationValue ? [relationValue] : [];
+            }
+        }
+        return transformed;
+    }
+
     async create(params)
     {
         try {
@@ -439,10 +516,13 @@ class PrismaDriver extends BaseDriver
     {
         try {
             let query = this.buildQueryOptions();
+            let includeConfig = {};
             if(sc.isArray(relations) && 0 < relations.length){
-                query.include = this.buildIncludeObject(relations);
+                includeConfig = this.buildIncludeObject(relations);
+                query.include = includeConfig;
             }
-            return await this.model.findMany(query);
+            let results = await this.model.findMany(query);
+            return this.transformRelationResults(results, includeConfig);
         } catch(error) {
             Logger.error('Load all with relations error: '+error.message);
             return [];
@@ -468,10 +548,13 @@ class PrismaDriver extends BaseDriver
             let processedFilters = this.processFilters(filters);
             let query = this.buildQueryOptions();
             query.where = processedFilters;
+            let includeConfig = {};
             if(sc.isArray(relations) && 0 < relations.length){
-                query.include = this.buildIncludeObject(relations);
+                includeConfig = this.buildIncludeObject(relations);
+                query.include = includeConfig;
             }
-            return await this.model.findMany(query);
+            let results = await this.model.findMany(query);
+            return this.transformRelationResults(results, includeConfig);
         } catch(error) {
             Logger.error('Load with relations error: '+error.message);
             return [];
@@ -497,10 +580,13 @@ class PrismaDriver extends BaseDriver
             let filter = this.createSingleFilter(field, fieldValue, operator);
             let query = this.buildQueryOptions();
             query.where = filter;
+            let includeConfig = {};
             if(sc.isArray(relations) && 0 < relations.length){
-                query.include = this.buildIncludeObject(relations);
+                includeConfig = this.buildIncludeObject(relations);
+                query.include = includeConfig;
             }
-            return await this.model.findMany(query);
+            let results = await this.model.findMany(query);
+            return this.transformRelationResults(results, includeConfig);
         } catch(error) {
             Logger.error('Load by with relations error: '+error.message);
             return [];
@@ -527,10 +613,13 @@ class PrismaDriver extends BaseDriver
             let query = {
                 where: {id: castedId}
             };
+            let includeConfig = {};
             if(sc.isArray(relations) && 0 < relations.length){
-                query.include = this.buildIncludeObject(relations);
+                includeConfig = this.buildIncludeObject(relations);
+                query.include = includeConfig;
             }
-            return await this.model.findUnique(query);
+            let result = await this.model.findUnique(query);
+            return this.transformRelationResults(result, includeConfig);
         } catch(error) {
             Logger.error('Load by ID with relations error: '+error.message);
             return null;
@@ -571,10 +660,13 @@ class PrismaDriver extends BaseDriver
             let processedFilters = this.processFilters(filters);
             let query = this.buildQueryOptions(false);
             query.where = processedFilters;
+            let includeConfig = {};
             if(sc.isArray(relations) && 0 < relations.length){
-                query.include = this.buildIncludeObject(relations);
+                includeConfig = this.buildIncludeObject(relations);
+                query.include = includeConfig;
             }
-            return await this.model.findFirst(query);
+            let result = await this.model.findFirst(query);
+            return this.transformRelationResults(result, includeConfig);
         } catch(error) {
             Logger.error('Load one with relations error: '+error.message);
             return null;
@@ -600,10 +692,13 @@ class PrismaDriver extends BaseDriver
             let filter = this.createSingleFilter(field, fieldValue, operator);
             let query = this.buildQueryOptions(false);
             query.where = filter;
+            let includeConfig = {};
             if(sc.isArray(relations) && 0 < relations.length){
-                query.include = this.buildIncludeObject(relations);
+                includeConfig = this.buildIncludeObject(relations);
+                query.include = includeConfig;
             }
-            return await this.model.findFirst(query);
+            let result = await this.model.findFirst(query);
+            return this.transformRelationResults(result, includeConfig);
         } catch(error) {
             Logger.error('Load one by with relations error: '+error.message);
             return null;
@@ -647,11 +742,11 @@ class PrismaDriver extends BaseDriver
             filter[field] = processedValue;
             return filter;
         }
-        filter[field] = this.applyOperator(processedValue, operator);
+        filter[field] = this.applyOperator(processedValue, operator, field);
         return filter;
     }
 
-    applyOperator(value, operator)
+    applyOperator(value, operator, fieldName = null)
     {
         let operatorsMap = {
             '=': value,
@@ -660,13 +755,24 @@ class PrismaDriver extends BaseDriver
             '>=': {gte: value},
             '<': {lt: value},
             '<=': {lte: value},
-            'LIKE': {contains: value},
+            'LIKE': this.handleLikeOperator(value, fieldName),
             'IN': {in: value},
             'NOT IN': {notIn: value}
         };
         return operatorsMap[operator] || value;
     }
 
+    handleLikeOperator(value, fieldName)
+    {
+        if('id' === fieldName || (this.referenceFields && sc.hasOwn(this.referenceFields, fieldName))){
+            let numericValue = Number(value.replace(/%/g, ''));
+            if(!isNaN(numericValue)){
+                return numericValue;
+            }
+        }
+        return {contains: value};
+    }
+
     buildIncludeObject(relations)
     {
         let include = {};

package/lib/prisma/prisma-schema-generator.js

@@ -62,19 +62,19 @@ class PrismaSchemaGenerator
     async waitForSchemaGeneration()
     {
         let clientPath = this.clientOutputPath || 'node_modules/.prisma/client';
-        let generatedClientPath = clientPath.startsWith('node_modules') 
-            ? FileHandler.joinPaths(process.cwd(), clientPath)
-            : FileHandler.joinPaths(this.prismaSchemaPath, clientPath);
+        let generatedClientPath = this.resolveClientPath(clientPath);
         let clientIndexPath = FileHandler.joinPaths(generatedClientPath, 'index.js');
         let startTime = Date.now();
         return new Promise((resolve) => {
             let interval = setInterval(() => {
+                let awaitTime = Date.now() - startTime;
+                Logger.info('Awaiting on schema generation: ' + clientIndexPath, (awaitTime/1000).toFixed(0));
                 if(FileHandler.exists(clientIndexPath)){
                     clearInterval(interval);
                     resolve();
                     return;
                 }
-                if(Date.now() - startTime > this.maxWaitTime){
+                if(awaitTime > this.maxWaitTime){
                     clearInterval(interval);
                     Logger.warning('Schema generation wait timeout reached.');
                     resolve();
@@ -83,6 +83,17 @@ class PrismaSchemaGenerator
         });
     }
 
+    resolveClientPath(clientPath)
+    {
+        if(clientPath.match(/^[a-zA-Z]:/) || clientPath.startsWith('/')){
+            return clientPath;
+        }
+        if(clientPath.startsWith('node_modules')){
+            return FileHandler.joinPaths(process.cwd(), clientPath);
+        }
+        return FileHandler.joinPaths(this.prismaSchemaPath, clientPath);
+    }
+
     generateSchemaFile()
     {
         let datasourceProvider = this.getDatasourceProvider();

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@reldens/storage",
     "scope": "@reldens",
-    "version": "0.56.0",
+    "version": "0.58.0",
     "description": "Reldens - Storage",
     "author": "Damian A. Pastorini",
     "license": "MIT",
@@ -45,13 +45,13 @@
         "@mikro-orm/core": "^6.4.16",
         "@mikro-orm/mongodb": "^6.4.16",
         "@mikro-orm/mysql": "^6.4.16",
-        "@prisma/client": "^6.9.0",
+        "@prisma/client": "^6.10.0",
         "@reldens/server-utils": "^0.19.0",
         "@reldens/utils": "^0.50.0",
         "knex": "^3.1.0",
         "mysql": "^2.18.1",
         "mysql2": "^3.14.1",
         "objection": "^3.1.5",
-        "prisma": "^6.9.0"
+        "prisma": "^6.10.0"
     }
 }