@reldens/storage 0.104.0 → 0.105.0

package/lib/entities-generator.js

@@ -9,6 +9,7 @@ const { Logger, sc } = require('@reldens/utils');
 const { ObjectionJsDataServer } = require('./objection-js/objection-js-data-server');
 const { MikroOrmDataServer } = require('./mikro-orm/mikro-orm-data-server');
 const { PrismaDataServer } = require('./prisma/prisma-data-server');
+const { PrismaRelationsMetadataExtractor } = require('./prisma/prisma-relations-metadata-extractor');
 const { EntitiesGeneration } = require('./generators/entities-generation');
 const { ModelsGeneration } = require('./generators/models-generation');
 const { EntitiesConfigGeneration } = require('./generators/entities-config-generation');
@@ -165,125 +166,6 @@ 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 = {};
@@ -386,7 +268,11 @@ class EntitiesGenerator
                 this.prismaClient = this.server.prisma;
             }
             //Logger.debug('Extract Prisma relations metadata.');
-            this.extractPrismaRelationsMetadata();
+            this.prismaRelationsMetadata = new PrismaRelationsMetadataExtractor({
+                prismaClient: this.prismaClient,
+                projectRoot: this.server ? this.server.projectRoot : false,
+                projectPath: this.projectPath
+            }).extract();
         }
         let tables = await this.server.fetchEntitiesFromDatabase();
         if(!tables){

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

@@ -17,21 +17,10 @@ class PrismaMetadataLoader
 
     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;
-            }
-            return null;
-        } catch(error) {
-            Logger.warning('Failed to access DMMF: '+error.message);
-            return null;
+        if(this.prisma && this.prisma._runtimeDataModel){
+            return this.prisma._runtimeDataModel;
         }
+        return null;
     }
 
     loadModelMetadata(tableName)

package/lib/prisma/prisma-relations-metadata-extractor.js

@@ -0,0 +1,137 @@
+/**
+ *
+ * Reldens - PrismaRelationsMetadataExtractor
+ *
+ * Builds the per-model relation metadata ({type: 'many'|'one', model, isList, isOptional, relationName})
+ * consumed by ModelsGeneration to emit each Prisma model's relationTypes. The DMMF access is reused from
+ * PrismaMetadataLoader.getDmmf(). Cardinality (list vs single) is read from schema.prisma's list markers
+ * ("[]") because Prisma 7's pruned _runtimeDataModel no longer exposes field.isList.
+ *
+ */
+
+const { PrismaMetadataLoader } = require('./prisma-metadata-loader');
+const { FileHandler } = require('@reldens/server-utils');
+const { Logger, sc } = require('@reldens/utils');
+
+class PrismaRelationsMetadataExtractor
+{
+
+    constructor(props)
+    {
+        this.prismaClient = sc.get(props, 'prismaClient', false);
+        this.projectRoot = sc.get(props, 'projectRoot', false);
+        this.projectPath = sc.get(props, 'projectPath', false);
+        this.metadataLoader = new PrismaMetadataLoader({prisma: this.prismaClient});
+        this.relationsMetadata = {};
+        this.schemaListRelations = {};
+    }
+
+    extract()
+    {
+        if(!this.prismaClient){
+            Logger.warning('Missing PrismaClient for relations metadata extraction.');
+            return this.relationsMetadata;
+        }
+        let dmmf = this.metadataLoader.getDmmf();
+        if(!dmmf || !dmmf.models){
+            Logger.warning('Could not access Prisma DMMF for relations metadata.');
+            return this.relationsMetadata;
+        }
+        this.schemaListRelations = this.resolveSchemaListRelations();
+        this.processModels(dmmf.models);
+        Logger.info('Extracted relations metadata for '+Object.keys(this.relationsMetadata).length+' models.');
+        return this.relationsMetadata;
+    }
+
+    processModels(models)
+    {
+        if(sc.isArray(models)){
+            for(let model of models){
+                this.processModel(sc.get(model, 'name', ''), model);
+            }
+            return;
+        }
+        for(let modelName of Object.keys(models)){
+            this.processModel(modelName, models[modelName]);
+        }
+    }
+
+    processModel(modelName, model)
+    {
+        if('' === modelName || !sc.isArray(sc.get(model, 'fields', false))){
+            return;
+        }
+        let tableName = modelName.toLowerCase();
+        this.relationsMetadata[tableName] = {};
+        for(let field of model.fields){
+            if('object' !== field.kind){
+                continue;
+            }
+            let isListRelation = true === sc.get(sc.get(this.schemaListRelations, tableName, {}), field.name, false);
+            this.relationsMetadata[tableName][field.name] = {
+                type: isListRelation ? 'many' : 'one',
+                model: field.type,
+                isList: isListRelation,
+                isOptional: field.isOptional,
+                relationName: field.relationName
+            };
+        }
+    }
+
+    resolveSchemaPath()
+    {
+        let candidatePaths = [];
+        if(this.projectRoot){
+            candidatePaths.push(FileHandler.joinPaths(this.projectRoot, 'prisma', 'schema.prisma'));
+        }
+        candidatePaths.push(FileHandler.joinPaths(process.cwd(), 'prisma', 'schema.prisma'));
+        if(this.projectPath){
+            candidatePaths.push(FileHandler.joinPaths(this.projectPath, 'prisma', 'schema.prisma'));
+        }
+        for(let candidatePath of candidatePaths){
+            if(FileHandler.exists(candidatePath)){
+                return candidatePath;
+            }
+        }
+        return false;
+    }
+
+    resolveSchemaListRelations()
+    {
+        let listRelations = {};
+        let schemaPath = this.resolveSchemaPath();
+        if(!schemaPath){
+            Logger.warning('Prisma schema.prisma not found; relation cardinality may fall back to one.');
+            return listRelations;
+        }
+        let schemaContent = FileHandler.readFile(schemaPath);
+        if(!schemaContent){
+            return listRelations;
+        }
+        let currentModel = '';
+        for(let schemaLine of schemaContent.toString().split('\n')){
+            let line = schemaLine.trim();
+            let modelMatch = line.match(/^model\s+(\w+)\s*\{/);
+            if(modelMatch){
+                currentModel = modelMatch[1].toLowerCase();
+                listRelations[currentModel] = {};
+                continue;
+            }
+            if('' === currentModel){
+                continue;
+            }
+            if('}' === line){
+                currentModel = '';
+                continue;
+            }
+            let listFieldMatch = line.match(/^(\w+)\s+\w+\[\]/);
+            if(listFieldMatch){
+                listRelations[currentModel][listFieldMatch[1]] = true;
+            }
+        }
+        return listRelations;
+    }
+
+}
+
+module.exports.PrismaRelationsMetadataExtractor = PrismaRelationsMetadataExtractor;

package/package.json

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