@reldens/storage 0.48.0 → 0.50.0

package/lib/entities-generator.js

@@ -44,7 +44,9 @@ class EntitiesGenerator
         };
         this.server = sc.get(props, 'server', false);
         this.connectionData = sc.get(props, 'connectionData', false);
+        this.isOverride = sc.get(props, 'isOverride', false);
         this.generatedEntities = {};
+        this.existingEntities = {};
     }
 
     async generateEntityFile(tableName, tableData)
@@ -98,7 +100,7 @@ class EntitiesGenerator
             Logger.critical('Failed to write entity file: '+filePath);
             return false;
         }
-        Logger.info('Generated entity file: '+filePath);
+        Logger.info('Generated entity file: '+fileName);
         this.generatedEntities[tableName] = {
             entityClassName,
             entityFileName: fileName,
@@ -295,16 +297,6 @@ class EntitiesGenerator
         return passwordFields;
     }
 
-    getEditPropertiesRemoval(fieldsToRemove)
-    {
-        if(1 === fieldsToRemove.length){
-            return 'let editProperties = [...propertiesKeys];\n        editProperties.splice(editProperties.indexOf(\''+
-                fieldsToRemove[0]
-                +'\'), 1);';
-        }
-        return 'let editProperties = sc.removeFromArray([...propertiesKeys], [\''+fieldsToRemove.join('\', \'')+'\']);';
-    }
-
     getListPropertiesDeclaration(columns)
     {
         let fieldsToRemove = this.getFieldsToRemoveFromList(columns);
@@ -355,10 +347,10 @@ class EntitiesGenerator
         }
         let filePath = FileHandler.joinPaths(driverFolder, fileName);
         if(!FileHandler.writeFile(filePath, modelContent)){
-            Logger.critical('Failed to write model file: '+filePath);
+            Logger.critical('Failed to write model file: '+fileName);
             return false;
         }
-        Logger.info('Generated model file: '+filePath);
+        Logger.info('Generated model file: '+fileName);
         this.generatedEntities[tableName].modelClassName = modelClassName;
         this.generatedEntities[tableName].modelFileName = fileName;
         this.generatedEntities[tableName].driverKey = driverKey;
@@ -406,57 +398,170 @@ class EntitiesGenerator
         return '';
     }
 
+    detectExistingEntities()
+    {
+        if(!FileHandler.exists(this.entitiesFolder)){
+            return;
+        }
+        let entityFiles = FileHandler.getFilesInFolder(this.entitiesFolder, ['.js']);
+        for(let file of entityFiles){
+            if(!file.endsWith('-entity.js')){
+                continue;
+            }
+            let tableName = file.replace('-entity.js', '').replace(/-/g, '_');
+            this.existingEntities[tableName] = {entityFileName: file, tableName};
+        }
+        Logger.info('Detected '+Object.keys(this.existingEntities).length+' existing entities.');
+    }
+
+    filterTablesToGenerate(tables)
+    {
+        if(this.isOverride){
+            return tables;
+        }
+        let filteredTables = {};
+        let newTablesCount = 0;
+        for(let tableName of Object.keys(tables)){
+            if(!this.existingEntities[tableName]){
+                filteredTables[tableName] = tables[tableName];
+                newTablesCount++;
+            }
+        }
+        if(0 === newTablesCount){
+            Logger.info('No new tables found. All entities are up to date.');
+        }
+        if(0 < newTablesCount){
+            Logger.info('Found '+newTablesCount+' new tables to generate entities for.');
+        }
+        return filteredTables;
+    }
+
     generateEntitiesConfigFile()
     {
-        let configTemplatePath = this.templates['entities-config'];
-        if(!FileHandler.exists(configTemplatePath)){
-            Logger.critical('Entities config template file not found: '+configTemplatePath);
-            return false;
+        if(this.isOverride){
+            return this.regenerateEntitiesConfigFile();
         }
-        let configTemplateContent = FileHandler.fetchFileContents(configTemplatePath);
+        return this.appendToEntitiesConfigFile();
+    }
+
+    regenerateEntitiesConfigFile()
+    {
+        let configTemplateContent = FileHandler.fetchFileContents(this.templates['entities-config']);
         if(!configTemplateContent) {
-            Logger.critical('Failed to read entities config template file: '+configTemplatePath);
+            Logger.critical('Failed to read entities config template file: '+this.templates['entities-config']);
             return false;
         }
-        let requireStatements = this.getRequireStatements();
-        let entitiesConfigExport = this.getEntitiesConfigExport();
+        let allEntities = Object.assign({}, this.existingEntities, this.generatedEntities);
         let replacements = {
-            requireStatements,
-            entitiesConfigExport
+            requireStatements: this.getRequireStatements(allEntities),
+            entitiesConfigExport: this.getEntitiesConfigExport(allEntities)
         };
-        let configContent = this.applyReplacements(configTemplateContent, replacements);
-        if (!FileHandler.writeFile(this.entitiesConfigPath, configContent)){
+        if(!FileHandler.writeFile(
+            this.entitiesConfigPath,
+            this.applyReplacements(configTemplateContent, replacements)
+        )){
             Logger.critical('Failed to write entities config file: '+this.entitiesConfigPath);
             return false;
         }
-        Logger.info('Generated entities config file: '+this.entitiesConfigPath);
+        Logger.info('Regenerated entities config file: '+this.entitiesConfigPath);
         return true;
     }
 
-    getRequireStatements()
+    appendToEntitiesConfigFile()
     {
-        let requireStatements = [];
+        if(0 === Object.keys(this.generatedEntities).length){
+            return true;
+        }
+        if(!FileHandler.exists(this.entitiesConfigPath)){
+            Logger.error('Entities config file does not exist, cannot append new entities.');
+            return false;
+        }
+        let existingContent = FileHandler.readFile(this.entitiesConfigPath);
+        if(!existingContent){
+            Logger.error('Could not read existing entities config file.');
+            return false;
+        }
+        let newRequires = [];
+        let newConfigs = [];
         for(let tableName of Object.keys(this.generatedEntities)){
             let entity = this.generatedEntities[tableName];
-            let nameWithoutExtension = entity.entityFileName.replace('.js', '');
+            let entityClassName = sc.get(entity, 'entityClassName', sc.capitalizedCamelCase(tableName)+'Entity');
+            let entityFileName = sc.get(entity, 'entityFileName', sc.kebabCase(tableName)+'-entity').replace('.js', '');
+            let requireStatement = 'const { '+ entityClassName+' } = require(\'./entities/'+entityFileName+'\');';
+            let configEntry = sc.camelCase(tableName)+': '+entityClassName+'.propertiesConfig()';
+            if(!existingContent.includes(requireStatement)){
+                newRequires.push(requireStatement);
+            }
+            if(!existingContent.includes(sc.camelCase(tableName)+':')){
+                newConfigs.push(configEntry);
+            }
+        }
+        if(0 === newRequires.length && 0 === newConfigs.length){
+            return true;
+        }
+        let firstRequirePosition = existingContent.indexOf('const {');
+        let entitiesConfigEnd = existingContent.indexOf('};\n\nmodule.exports');
+        if(-1 === firstRequirePosition || -1 === entitiesConfigEnd){
+            Logger.error('Could not find insertion points in config file.');
+            return false;
+        }
+        let beforeFirstRequire = existingContent.substring(0, firstRequirePosition);
+        let afterFirstRequire = existingContent.substring(firstRequirePosition, entitiesConfigEnd);
+        let updatedContent = beforeFirstRequire;
+        if(0 < newRequires.length){
+            updatedContent += newRequires.join('\n') + '\n';
+        }
+        updatedContent += afterFirstRequire;
+        if(0 < newConfigs.length){
+            if(!afterFirstRequire.trim().endsWith(',')){
+                updatedContent = updatedContent.trimEnd() + ',';
+            }
+            updatedContent += '\n    ' + newConfigs.join(',\n    ') + '\n';
+        }
+        updatedContent += existingContent.substring(entitiesConfigEnd);
+        if(!FileHandler.writeFile(this.entitiesConfigPath, updatedContent)){
+            Logger.error('Failed to append to entities config file: '+this.entitiesConfigPath);
+            return false;
+        }
+        return true;
+    }
+
+    getRequireStatements(allEntities)
+    {
+        let requireStatements = [];
+        for(let tableName of Object.keys(allEntities)){
+            let entity = allEntities[tableName];
+            let entityClassName = sc.get(entity, 'entityClassName', sc.capitalizedCamelCase(tableName)+'Entity');
+            let entityFileName = sc.get(entity, 'entityFileName', sc.kebabCase(tableName)+'-entity').replace('.js', '');
             requireStatements.push(
-                'const { '+ entity.entityClassName+' } = require(\'./entities/'+nameWithoutExtension+'\');'
+                'const { '+ entityClassName+' } = require(\'./entities/'+entityFileName+'\');'
             );
         }
         return requireStatements.join('\n');
     }
 
-    getEntitiesConfigExport()
+    getEntitiesConfigExport(allEntities)
     {
         let entitiesConfigExport = [];
-        for(let tableName of Object.keys(this.generatedEntities)){
-            let entity = this.generatedEntities[tableName];
-            entitiesConfigExport.push(sc.camelCase(tableName)+': '+entity.entityClassName+'.propertiesConfig()');
+        for(let tableName of Object.keys(allEntities)){
+            entitiesConfigExport.push(
+                sc.camelCase(tableName)+': '
+                +sc.get(allEntities[tableName], 'entityClassName', sc.capitalizedCamelCase(tableName)+'Entity')
+                +'.propertiesConfig()'
+            );
         }
         return entitiesConfigExport.join(',\n    ');
     }
 
     generateEntitiesTranslationsFile()
+    {
+        if(this.isOverride){
+            return this.regenerateEntitiesTranslationsFile();
+        }
+        return this.appendToEntitiesTranslationsFile();
+    }
+
+    regenerateEntitiesTranslationsFile()
     {
         let translationsTemplatePath = this.templates['entities-translations'];
         if(!FileHandler.exists(translationsTemplatePath)){
@@ -468,22 +573,72 @@ class EntitiesGenerator
             Logger.critical('Failed to read entities translations template file: '+translationsTemplatePath);
             return false;
         }
-        let labels = this.getTranslationLabels();
-        let translationsContent = translationsTemplateContent.replace(/{{labels}}/g, labels);
+        let translationsContent = translationsTemplateContent.replace(
+            /{{labels}}/g,
+            this.getTranslationLabels(Object.assign({}, this.existingEntities, this.generatedEntities))
+        );
         if(!FileHandler.writeFile(this.entitiesTranslationsPath, translationsContent)){
             Logger.critical('Failed to write entities translations file: '+this.entitiesTranslationsPath);
             return false;
         }
-        Logger.info('Generated entities translations file: '+this.entitiesTranslationsPath);
+        Logger.info('Regenerated entities translations file: '+this.entitiesTranslationsPath);
         return true;
     }
 
-    getTranslationLabels()
+    appendToEntitiesTranslationsFile()
     {
-        let labels = [];
+        if(0 === Object.keys(this.generatedEntities).length){
+            return true;
+        }
+        if(!FileHandler.exists(this.entitiesTranslationsPath)){
+            Logger.error('Entities translations file does not exist, cannot append new entities.');
+            return false;
+        }
+        let existingContent = FileHandler.readFile(this.entitiesTranslationsPath);
+        if(!existingContent){
+            Logger.error('Could not read existing translations file.');
+            return false;
+        }
+        let newTranslations = [];
         for(let tableName of Object.keys(this.generatedEntities)){
-            let humanReadable = tableName.split('_').map(word => word.charAt(0).toUpperCase()+word.slice(1)).join(' ');
-            labels.push('\''+tableName+'\': \''+humanReadable+'\'');
+            if(!existingContent.includes('\''+tableName+'\':')){
+                newTranslations.push(
+                    '\''+tableName+'\': \''
+                    +tableName.split('_').map(word => word.charAt(0).toUpperCase()+word.slice(1)).join(' ')+'\''
+                );
+            }
+        }
+        if(0 === newTranslations.length){
+            return true;
+        }
+        let labelsEnd = existingContent.indexOf('\n    }\n');
+        if(-1 === existingContent.indexOf('labels: {') || -1 === labelsEnd){
+            Logger.error('Could not find labels object boundaries in existing translations file.');
+            return false;
+        }
+        let beforeLabelsEnd = existingContent.substring(0, labelsEnd);
+        if(!beforeLabelsEnd.trim().endsWith(',')){
+            beforeLabelsEnd = beforeLabelsEnd.trimEnd() + ',';
+        }
+        if(!FileHandler.writeFile(
+            this.entitiesTranslationsPath,
+            beforeLabelsEnd + '\n        ' + newTranslations.join(',\n        ') + existingContent.substring(labelsEnd)
+        )){
+            Logger.error('Failed to append to entities translations file: '+this.entitiesTranslationsPath);
+            return false;
+        }
+        return true;
+    }
+
+    getTranslationLabels(allEntities)
+    {
+        let labels = [];
+        for(let tableName of Object.keys(allEntities)){
+            labels.push(
+                '\''+tableName+'\': \''
+                +tableName.split('_').map(word => word.charAt(0).toUpperCase()+word.slice(1)).join(' ')
+                +'\''
+            );
         }
         return labels.join(',\n        ');
     }
@@ -500,9 +655,10 @@ class EntitiesGenerator
             Logger.critical('Failed to read registered models template file: '+registeredTemplatePath);
             return false;
         }
+        let allEntities = Object.assign({}, this.existingEntities, this.generatedEntities);
         let replacements = {
-            registeredModels: this.getRegisteredModels(driverKey),
-            registeredEntitiesObject: this.getRegisteredEntitiesObject(driverKey)
+            registeredModels: this.getRegisteredModels(allEntities, driverKey),
+            registeredEntitiesObject: this.getRegisteredEntitiesObject(allEntities, driverKey)
         };
         let registeredContent = this.applyReplacements(registeredTemplateContent, replacements);
         let driverFolder = FileHandler.joinPaths(this.modelsFolder, driverKey);
@@ -515,30 +671,33 @@ class EntitiesGenerator
         return true;
     }
 
-    getRegisteredModels(driverKey)
+    getRegisteredModels(allEntities, driverKey)
     {
         let registeredModels = [];
-        for(let tableName of Object.keys(this.generatedEntities)){
-            let entity = this.generatedEntities[tableName];
-            if(driverKey !== entity.driverKey){
+        for(let tableName of Object.keys(allEntities)){
+            let entity = allEntities[tableName];
+            if(entity.driverKey && driverKey !== entity.driverKey){
                 continue;
             }
+            let modelClassName = entity.modelClassName || sc.capitalizedCamelCase(tableName)+'Model';
+            let modelFileName = entity.modelFileName || sc.kebabCase(tableName)+'-model.js';
             registeredModels.push(
-                'const { '+entity.modelClassName+' } = require(\'./'+entity.modelFileName.replace('.js', '')+'\');'
+                'const { '+modelClassName+' } = require(\'./'+modelFileName.replace('.js', '')+'\');'
             );
         }
         return registeredModels.join('\n');
     }
 
-    getRegisteredEntitiesObject(driverKey)
+    getRegisteredEntitiesObject(allEntities, driverKey)
     {
         let registeredEntitiesObject = [];
-        for(let tableName of Object.keys(this.generatedEntities)){
-            let entity = this.generatedEntities[tableName];
-            if(driverKey !== entity.driverKey){
+        for(let tableName of Object.keys(allEntities)){
+            let entity = allEntities[tableName];
+            if(entity.driverKey && driverKey !== entity.driverKey){
                 continue;
             }
-            registeredEntitiesObject.push(sc.camelCase(tableName)+': '+entity.modelClassName);
+            let modelClassName = entity.modelClassName || sc.capitalizedCamelCase(tableName)+'Model';
+            registeredEntitiesObject.push(sc.camelCase(tableName)+': '+modelClassName);
         }
         return registeredEntitiesObject.join(',\n    ');
     }
@@ -571,6 +730,11 @@ class EntitiesGenerator
         if(!this.ensureFoldersExist()){
             return false;
         }
+        this.detectExistingEntities();
+        let tablesToGenerate = this.filterTablesToGenerate(tables);
+        if(0 === Object.keys(tablesToGenerate).length && !this.isOverride){
+            return true;
+        }
         let driverKey = sc.get(
             this.connectionData,
             'driver',
@@ -580,8 +744,8 @@ class EntitiesGenerator
             Logger.critical('Failed to fetch driver key.');
             return false;
         }
-        for(let tableName of Object.keys(tables)){
-            let tableData = tables[tableName];
+        for(let tableName of Object.keys(tablesToGenerate)){
+            let tableData = tablesToGenerate[tableName];
             await this.generateEntityFile(tableName, tableData);
             await this.generateModelFile(tableName, tableData, driverKey);
         }

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@reldens/storage",
     "scope": "@reldens",
-    "version": "0.48.0",
+    "version": "0.50.0",
     "description": "Reldens - Storage",
     "author": "Damian A. Pastorini",
     "license": "MIT",
@@ -42,12 +42,12 @@
         "url": "https://github.com/damian-pastorini/reldens-storage/issues"
     },
     "dependencies": {
-        "@mikro-orm/core": "^6.4.15",
-        "@mikro-orm/mongodb": "^6.4.15",
-        "@mikro-orm/mysql": "^6.4.15",
+        "@mikro-orm/core": "^6.4.16",
+        "@mikro-orm/mongodb": "^6.4.16",
+        "@mikro-orm/mysql": "^6.4.16",
         "@prisma/client": "^6.8.2",
         "@reldens/server-utils": "^0.18.0",
-        "@reldens/utils": "^0.49.0",
+        "@reldens/utils": "^0.50.0",
         "knex": "^3.1.0",
         "mysql": "^2.18.1",
         "mysql2": "^3.14.1",