@reldens/storage 0.104.0 → 0.106.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/generators/entities-generation.js

@@ -215,6 +215,7 @@ class EntitiesGeneration extends BaseGenerator
         let type = column.type.toLowerCase();
         this.addTypeAttribute(props, column, type, columnName, referenceCounts);
         this.addRequiredAttribute(props, column);
+        this.addUniqueAttribute(props, column);
         props.push('dbType: \''+type+'\'');
         return props;
     }
@@ -295,6 +296,13 @@ class EntitiesGeneration extends BaseGenerator
         }
     }
 
+    addUniqueAttribute(props, column)
+    {
+        if('UNI' === column.key){
+            props.push('isUnique: true');
+        }
+    }
+
     getReferenceTable(column)
     {
         if(column.referencedTable){

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)
@@ -50,6 +39,7 @@ class PrismaMetadataLoader
         let metadata = {
             requiredFields: [],
             optionalFields: [],
+            uniqueFields: [],
             fieldTypes: {},
             fieldDefaults: {},
             idFieldType: 'String',
@@ -92,6 +82,9 @@ class PrismaMetadataLoader
         if(field.isOptional || field.hasDefaultValue){
             metadata.optionalFields.push(field.name);
         }
+        if(field.isUnique){
+            metadata.uniqueFields.push(field.name);
+        }
         if(field.kind === 'scalar' && field.isList === false){
             let isNumericType = this.isNumericFieldType(field.type);
             let isReferenceField = field.relationFromFields && 0 < field.relationFromFields.length;

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.106.0",
     "description": "Reldens - Storage",
     "author": "Damian A. Pastorini",
     "license": "MIT",
@@ -51,16 +51,16 @@
         "test:driver": "node tests/run-tests.js --driver="
     },
     "dependencies": {
-        "@mikro-orm/core": "7.1.5",
-        "@mikro-orm/mongodb": "7.1.5",
-        "@mikro-orm/mysql": "7.1.5",
+        "@mikro-orm/core": "7.1.6",
+        "@mikro-orm/mongodb": "7.1.6",
+        "@mikro-orm/mysql": "7.1.6",
         "@prisma/adapter-mariadb": "7.8.0",
         "@prisma/client": "7.8.0",
         "@reldens/server-utils": "^0.53.0",
         "@reldens/utils": "^0.57.0",
         "knex": "3.3.0",
         "mysql": "2.18.1",
-        "mysql2": "3.22.6",
+        "mysql2": "3.23.0",
         "objection": "3.1.5",
         "prisma": "7.8.0"
     }

package/tests/fixtures/expected-entities/entities/test-categories-entity.js

@@ -26,6 +26,7 @@ class TestCategoriesEntity extends EntityProperties
             },
             slug: {
                 isRequired: true,
+                isUnique: true,
                 dbType: 'varchar'
             },
             description: {

package/tests/fixtures/expected-entities/entities/test-products-entity.js

@@ -33,6 +33,7 @@ class TestProductsEntity extends EntityProperties
             },
             sku: {
                 isRequired: true,
+                isUnique: true,
                 dbType: 'varchar'
             },
             description: {

package/tests/run-tests.js

@@ -15,6 +15,7 @@ const RawQueriesTest = require('./integration/test-raw-queries');
 const EntityManagerTest = require('./unit/test-entity-manager');
 const TypeMapperTest = require('./unit/test-type-mapper');
 const DriversUnitTest = require('./unit/test-drivers');
+const EntitiesGenerationTest = require('./unit/test-entities-generation');
 
 if(!process.env.RELDENS_TEST_DB_HOST){
     let envPath = FileHandler.joinPaths(__dirname, '.env.test');
@@ -187,6 +188,11 @@ class RunTests
         this.allCounts.total += driversUnitResult.total;
         this.allCounts.passed += driversUnitResult.passed;
         this.allCounts.failed += driversUnitResult.failed;
+        let entitiesGenerationTest = new EntitiesGenerationTest();
+        let entitiesGenerationResult = await entitiesGenerationTest.run();
+        this.allCounts.total += entitiesGenerationResult.total;
+        this.allCounts.passed += entitiesGenerationResult.passed;
+        this.allCounts.failed += entitiesGenerationResult.failed;
     }
 
     async runPreFlightChecks(config)

package/tests/unit/test-entities-generation.js

@@ -0,0 +1,152 @@
+/**
+ *
+ * Reldens - EntitiesGeneration Test
+ *
+ */
+
+const { TestRunner, assert } = require('../utils/test-runner');
+const { EntitiesGeneration } = require('../../lib/generators/entities-generation');
+
+class EntitiesGenerationTest
+{
+
+    constructor()
+    {
+        this.runner = new TestRunner();
+    }
+
+    createColumn(props)
+    {
+        return Object.assign(
+            {
+                name: 'test_column',
+                type: 'varchar',
+                columnType: 'varchar(100)',
+                length: '100',
+                nullable: true,
+                key: '',
+                extra: '',
+                default: null
+            },
+            props
+        );
+    }
+
+    async run()
+    {
+        this.runner.suite('EntitiesGeneration');
+        await this.testAddUniqueAttribute();
+        await this.testGetPropertyAttributesUnique();
+        await this.testGeneratePropertiesConfigUnique();
+        return this.runner.getResults();
+    }
+
+    async testAddUniqueAttribute()
+    {
+        this.runner.group('addUniqueAttribute');
+        let generation = new EntitiesGeneration({});
+        await this.runner.test('should push isUnique for a UNI column', async () => {
+            let props = [];
+            generation.addUniqueAttribute(props, this.createColumn({key: 'UNI'}));
+            assert.deepStrictEqual(props, ['isUnique: true']);
+        });
+        await this.runner.test('should not push isUnique for a non indexed column', async () => {
+            let props = [];
+            generation.addUniqueAttribute(props, this.createColumn({key: ''}));
+            assert.deepStrictEqual(props, []);
+        });
+        await this.runner.test('should not push isUnique for a MUL column', async () => {
+            let props = [];
+            generation.addUniqueAttribute(props, this.createColumn({key: 'MUL'}));
+            assert.deepStrictEqual(props, []);
+        });
+        await this.runner.test('should not push isUnique for a PRI column', async () => {
+            let props = [];
+            generation.addUniqueAttribute(props, this.createColumn({key: 'PRI'}));
+            assert.deepStrictEqual(props, []);
+        });
+    }
+
+    async testGetPropertyAttributesUnique()
+    {
+        this.runner.group('getPropertyAttributes - isUnique');
+        let generation = new EntitiesGeneration({});
+        await this.runner.test('should include isUnique for a UNI column', async () => {
+            let column = this.createColumn({name: 'slug', key: 'UNI'});
+            let props = generation.getPropertyAttributes(column, 'slug', {});
+            assert.ok(props.includes('isUnique: true'));
+        });
+        await this.runner.test('should not include isUnique for a non unique column', async () => {
+            let column = this.createColumn({name: 'tags', key: ''});
+            let props = generation.getPropertyAttributes(column, 'tags', {});
+            assert.deepStrictEqual(props, ['dbType: \'varchar\'']);
+        });
+        await this.runner.test('should include both isRequired and isUnique for a required unique column', async () => {
+            let column = this.createColumn({name: 'sku', key: 'UNI', nullable: false});
+            let props = generation.getPropertyAttributes(column, 'sku', {});
+            assert.deepStrictEqual(props, ['isRequired: true', 'isUnique: true', 'dbType: \'varchar\'']);
+        });
+        await this.runner.test('should include isUnique only for a nullable unique column', async () => {
+            let column = this.createColumn({name: 'sku', key: 'UNI', nullable: true});
+            let props = generation.getPropertyAttributes(column, 'sku', {});
+            assert.deepStrictEqual(props, ['isUnique: true', 'dbType: \'varchar\'']);
+        });
+        await this.runner.test('should not include isUnique for a composite unique member column', async () => {
+            let column = this.createColumn({name: 'owner_id', type: 'int', key: 'MUL', nullable: false});
+            let props = generation.getPropertyAttributes(column, 'owner_id', {});
+            assert.deepStrictEqual(props, ['type: \'number\'', 'isRequired: true', 'dbType: \'int\'']);
+        });
+        await this.runner.test('should not include isUnique for the primary key column', async () => {
+            let column = this.createColumn({name: 'id', type: 'int', key: 'PRI', nullable: false, extra: 'auto_increment'});
+            let props = generation.getPropertyAttributes(column, 'id', {});
+            assert.deepStrictEqual(props, ['type: \'number\'', 'isRequired: true', 'dbType: \'int\'']);
+        });
+        await this.runner.test('should include isUnique for a unique reference column', async () => {
+            let column = this.createColumn({
+                name: 'profile_id',
+                type: 'int',
+                key: 'UNI',
+                nullable: false,
+                referencedTable: 'profiles',
+                referencedColumn: 'id'
+            });
+            let props = generation.getPropertyAttributes(column, 'profile_id', {profiles: 1});
+            assert.deepStrictEqual(props, [
+                'type: \'reference\'',
+                'reference: \'profiles\'',
+                'alias: \'related_profiles\'',
+                'isRequired: true',
+                'isUnique: true',
+                'dbType: \'int\''
+            ]);
+        });
+    }
+
+    async testGeneratePropertiesConfigUnique()
+    {
+        this.runner.group('generatePropertiesConfig - isUnique');
+        let generation = new EntitiesGeneration({});
+        await this.runner.test('should render isUnique in the generated properties config', async () => {
+            let columns = {
+                id: this.createColumn({name: 'id', type: 'int', key: 'PRI', nullable: false}),
+                slug: this.createColumn({name: 'slug', key: 'UNI', nullable: false}),
+                tags: this.createColumn({name: 'tags', key: ''})
+            };
+            let propertiesConfig = generation.generatePropertiesConfig(columns, false, 'id');
+            assert.ok(propertiesConfig.includes('slug: {'));
+            assert.ok(propertiesConfig.includes('isUnique: true'));
+            assert.strictEqual(propertiesConfig.split('isUnique: true').length - 1, 1);
+        });
+        await this.runner.test('should not render isUnique when no unique columns exist', async () => {
+            let columns = {
+                id: this.createColumn({name: 'id', type: 'int', key: 'PRI', nullable: false}),
+                tags: this.createColumn({name: 'tags', key: ''})
+            };
+            let propertiesConfig = generation.generatePropertiesConfig(columns, false, 'id');
+            assert.ok(!propertiesConfig.includes('isUnique'));
+        });
+    }
+
+}
+
+module.exports = EntitiesGenerationTest;