@reldens/storage 0.103.0 → 0.105.0

package/CLAUDE.md

@@ -150,7 +150,7 @@ npx reldens-storage-prisma --host=<host> --database=<db> --user=<user> --passwor
   - **Type caster isolation**: PrismaTypeCaster never requires `@prisma/client` directly, receives `prismaDbNull` as prop
 - **Prisma v7 breaking changes applied:**
   - Requires `@prisma/adapter-mariadb` for MySQL connections (WASM engine mandates a driver adapter)
-  - `datasource` block in `schema.prisma` no longer accepts `url` - connection URL is provided via `prisma.config.js` generated at project root using `{ datasource: { url: process.env.DATABASE_URL } }`
+  - `datasource` block in `schema.prisma` no longer accepts `url` - connection URL is provided via `prisma.config.js` generated at project root using `process.loadEnvFile('.env')` + `{ datasource: { url: process.env.RELDENS_DB_URL } }`
   - `PrismaClient` constructor no longer accepts `datasources` or `datasourceUrl` - use `adapter: new PrismaMariaDb(connectionString)` instead
   - `provider = "prisma-client-js"` is kept (deprecated but functional); switching to `prisma-client` would require additional adapter changes
   - `_runtimeDataModel` in Prisma 7 is pruned: fields only contain `{ name, kind, type, relationName, dbName }` - `isId`, `isRequired`, `hasDefaultValue` are stripped. ID field detection falls back to `field.name === 'id' && field.kind === 'scalar'`

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-client-loader.js

@@ -29,7 +29,7 @@ class PrismaClientLoader
         }
         if(!connectionData){
             Logger.info('Creating PrismaClient with default connection from schema');
-            return PrismaClientLoader.createWithAdapter(prismaModule.PrismaClient, process.env.DATABASE_URL);
+            return PrismaClientLoader.createWithAdapter(prismaModule.PrismaClient, process.env.RELDENS_DB_URL);
         }
         let connectionString = connectionData.client+'://'
             +connectionData.user

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/lib/prisma/prisma-schema-generator.js

@@ -96,7 +96,7 @@ class PrismaSchemaGenerator
     setDatabaseEnvironmentVariables()
     {
         let datasourceProvider = this.getDatasourceProvider();
-        process.env.DATABASE_URL = this.buildConnectionString(datasourceProvider);
+        process.env.RELDENS_DB_URL = this.buildConnectionString(datasourceProvider);
         if(this.dataProxy){
             process.env.DATABASE_DIRECT_URL = this.buildDirectConnectionString(datasourceProvider);
         }
@@ -139,7 +139,8 @@ class PrismaSchemaGenerator
 
     generateConfigFile()
     {
-        let configContent = 'module.exports = { datasource: { url: process.env.DATABASE_URL } };\n';
+        let configContent = 'process.loadEnvFile(\'.env\');\n'
+            +'module.exports = { datasource: { url: process.env.RELDENS_DB_URL } };\n';
         let configPath = FileHandler.joinPaths(process.cwd(), 'prisma.config.js');
         FileHandler.writeFile(configPath, configContent);
         Logger.info('Generated Prisma config file at: '+configPath);

package/package.json

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

package/tests/utils/test-helpers.js

@@ -387,7 +387,7 @@ class TestHelpers
             let { PrismaMariaDb } = require('@prisma/adapter-mariadb');
             let adapterConfig = config
                 ? { host: config.host, port: config.port, user: config.user, password: config.password, database: config.database }
-                : process.env.DATABASE_URL;
+                : process.env.RELDENS_DB_URL;
             let client = new PrismaClient({ adapter: new PrismaMariaDb(adapterConfig) });
             await client.$connect();
             return client;