@reldens/storage 0.53.0 → 0.55.0

package/lib/generators/base-generator.js

@@ -0,0 +1,21 @@
+/**
+ *
+ * Reldens - BaseGenerator
+ *
+ */
+
+class BaseGenerator
+{
+
+    applyReplacements(content, replacements)
+    {
+        let result = content;
+        for(let placeholder of Object.keys(replacements)){
+            result = result.replace(new RegExp('{{'+placeholder+'}}','g'), replacements[placeholder]);
+        }
+        return result;
+    }
+
+}
+
+module.exports.BaseGenerator = BaseGenerator;

package/lib/generators/entities-config-generation.js

@@ -0,0 +1,174 @@
+/**
+ *
+ * Reldens - EntitiesConfigGeneration
+ *
+ */
+
+const { FileHandler } = require('@reldens/server-utils');
+const { Logger, sc } = require('@reldens/utils');
+const { BaseGenerator } = require('./base-generator');
+
+class EntitiesConfigGeneration extends BaseGenerator
+{
+
+    constructor(props)
+    {
+        super();
+        this.entitiesConfigPath = sc.get(props, 'entitiesConfigPath', '');
+        this.templatePath = sc.get(props, 'templatePath', '');
+    }
+
+    generateEntitiesConfigFile(generatedEntities, existingEntities, isOverride)
+    {
+        if(isOverride){
+            return this.regenerateEntitiesConfigFile(generatedEntities, existingEntities);
+        }
+        return this.appendToEntitiesConfigFile(generatedEntities);
+    }
+
+    regenerateEntitiesConfigFile(generatedEntities, existingEntities)
+    {
+        let configTemplateContent = FileHandler.fetchFileContents(this.templatePath);
+        if(!configTemplateContent){
+            Logger.critical('Failed to read entities config template file: '+this.templatePath);
+            return false;
+        }
+        let allEntities = Object.assign({}, existingEntities, generatedEntities);
+        let replacements = {
+            requireStatements: this.getRequireStatements(allEntities),
+            entitiesConfigExport: this.getEntitiesConfigExport(allEntities)
+        };
+        if(!FileHandler.writeFile(
+            this.entitiesConfigPath,
+            this.applyReplacements(configTemplateContent, replacements)
+        )){
+            Logger.critical('Failed to write entities config file: '+this.entitiesConfigPath);
+            return false;
+        }
+        Logger.info('Regenerated entities config file: '+this.entitiesConfigPath);
+        return true;
+    }
+
+    appendToEntitiesConfigFile(generatedEntities)
+    {
+        if(0 === Object.keys(generatedEntities).length){
+            return true;
+        }
+        if(!FileHandler.exists(this.entitiesConfigPath)){
+            Logger.info('Entities config file does not exist, creating new file.');
+            return this.regenerateEntitiesConfigFile(generatedEntities, {});
+        }
+        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(generatedEntities)){
+            let entity = generatedEntities[tableName];
+            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(!this.entityExistsInConfig(tableName, existingContent)){
+                newConfigs.push(configEntry);
+            }
+        }
+        if(0 === newRequires.length && 0 === newConfigs.length){
+            return true;
+        }
+        let normalizedContent = existingContent.replace(/\s+/g, ' ');
+        let entitiesConfigPattern = /let\s+entitiesConfig\s*=\s*\{/;
+        let entitiesConfigMatch = normalizedContent.match(entitiesConfigPattern);
+        if(!entitiesConfigMatch){
+            Logger.error('Could not find entitiesConfig variable in config file.');
+            return false;
+        }
+        let entitiesConfigStart = existingContent.indexOf(entitiesConfigMatch[0]);
+        let searchStart = entitiesConfigStart + entitiesConfigMatch[0].length;
+        let braceCount = 1;
+        let entitiesConfigEnd = -1;
+        for(let i = searchStart; i < existingContent.length; i++){
+            if('{' === existingContent[i]){
+                braceCount++;
+            }
+            if('}' === existingContent[i]){
+                braceCount--;
+                if(0 === braceCount){
+                    entitiesConfigEnd = i;
+                    break;
+                }
+            }
+        }
+        if(-1 === entitiesConfigEnd){
+            Logger.error('Could not find end of entitiesConfig object.');
+            return false;
+        }
+        let firstRequirePosition = existingContent.indexOf('const {');
+        if(-1 === firstRequirePosition){
+            Logger.error('Could not find require statements in config file.');
+            return false;
+        }
+        let beforeFirstRequire = existingContent.substring(0, firstRequirePosition);
+        let afterFirstRequire = existingContent.substring(firstRequirePosition, entitiesConfigEnd);
+        let afterConfig = existingContent.substring(entitiesConfigEnd);
+        let updatedContent = beforeFirstRequire;
+        if(0 < newRequires.length){
+            updatedContent += newRequires.join('\n') + '\n';
+        }
+        updatedContent += afterFirstRequire;
+        if(0 < newConfigs.length){
+            let trimmedContent = afterFirstRequire.trimEnd();
+            if(!trimmedContent.endsWith(',')){
+                updatedContent = updatedContent.trimEnd() + ',';
+            }
+            updatedContent += '\n    ' + newConfigs.join(',\n    ');
+        }
+        updatedContent += afterConfig;
+        if(!FileHandler.writeFile(this.entitiesConfigPath, updatedContent)){
+            Logger.error('Failed to append to entities config file: '+this.entitiesConfigPath);
+            return false;
+        }
+        Logger.info('Updated entities config file with '+newConfigs.length+' new entities.');
+        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 { '+ entityClassName+' } = require(\'./entities/'+entityFileName+'\');'
+            );
+        }
+        return requireStatements.join('\n');
+    }
+
+    getEntitiesConfigExport(allEntities)
+    {
+        let entitiesConfigExport = [];
+        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    ');
+    }
+
+    entityExistsInConfig(tableName, configContent)
+    {
+        return configContent.includes(sc.camelCase(tableName)+':');
+    }
+
+}
+
+module.exports.EntitiesConfigGeneration = EntitiesConfigGeneration;

package/lib/generators/entities-generation.js

@@ -0,0 +1,286 @@
+/**
+ *
+ * Reldens - EntitiesGeneration
+ *
+ */
+
+const { FileHandler } = require('@reldens/server-utils');
+const { Logger, sc } = require('@reldens/utils');
+const { TypeMapper } = require('../type-mapper');
+const { BaseGenerator } = require('./base-generator');
+
+class EntitiesGeneration extends BaseGenerator
+{
+
+    constructor(props)
+    {
+        super();
+        this.entitiesFolder = sc.get(props, 'entitiesFolder', '');
+        this.templatePath = sc.get(props, 'templatePath', '');
+        this.generatedEntities = {};
+    }
+
+    async generateEntityFile(tableName, tableData)
+    {
+        if(!FileHandler.exists(this.templatePath)){
+            Logger.critical('Entity template file not found: '+this.templatePath);
+            return false;
+        }
+        let entityTemplateContent = FileHandler.fetchFileContents(this.templatePath);
+        if(!entityTemplateContent){
+            Logger.critical('Failed to read entity template file: '+this.templatePath);
+            return false;
+        }
+        let entityClassName = sc.capitalizedCamelCase(tableName)+'Entity';
+        let titleProperty = this.determineTitleProperty(tableData.columns);
+        for(let columnName of Object.keys(tableData.columns)){
+            tableData.columns[columnName].tableName = tableName;
+        }
+        let propertiesConfig = this.generatePropertiesConfig(tableData.columns, titleProperty);
+        let titlePropertyDeclaration = titleProperty ? '\n        let titleProperty = \''+titleProperty+'\';' : '';
+        let titlePropertyReturn = titleProperty ? '\n            titleProperty,' : '';
+        let fieldsToRemoveFromEdit = ['id'];
+        if(tableData.columns['created_at']){
+            fieldsToRemoveFromEdit.push('created_at');
+        }
+        if(tableData.columns['updated_at']){
+            fieldsToRemoveFromEdit.push('updated_at');
+        }
+        let editPropertiesRemoval = this.getEditPropertiesRemoval(fieldsToRemoveFromEdit);
+        let listPropertiesDeclaration = this.getListPropertiesDeclaration(tableData.columns);
+        let showPropertiesDeclaration = this.getShowPropertiesDeclaration(tableData.columns);
+        let needsSc = listPropertiesDeclaration.includes('sc.removeFromArray')
+            || editPropertiesRemoval.includes('sc.removeFromArray')
+            || showPropertiesDeclaration.includes('sc.removeFromArray');
+        let scRequire = needsSc ? '\nconst { sc } = require(\'@reldens/utils\');' : '';
+        let replacements = {
+            entityClassName,
+            propertiesConfig,
+            titlePropertyDeclaration,
+            titlePropertyReturn,
+            showPropertiesDeclaration,
+            editPropertiesRemoval,
+            listPropertiesDeclaration,
+            scRequire
+        };
+        let entityContent = this.applyReplacements(entityTemplateContent, replacements);
+        let fileName = sc.kebabCase(tableName)+'-entity.js';
+        let filePath = FileHandler.joinPaths(this.entitiesFolder, fileName);
+        if(!FileHandler.writeFile(filePath, entityContent)){
+            Logger.critical('Failed to write entity file: '+filePath);
+            return false;
+        }
+        Logger.info('Generated entity file: '+fileName);
+        this.generatedEntities[tableName] = {
+            entityClassName,
+            entityFileName: fileName,
+            tableName,
+            titleProperty
+        };
+        return true;
+    }
+
+    getFieldsToRemoveFromList(columns)
+    {
+        let fieldsToRemove = [];
+        for(let columnName of Object.keys(columns)){
+            let column = columns[columnName];
+            let type = column.type.toLowerCase();
+            if(['text', 'json', 'tinytext', 'mediumtext', 'longtext'].includes(type)){
+                fieldsToRemove.push(columnName);
+            }
+            if('password' === columnName.toLowerCase()){
+                fieldsToRemove.push(columnName);
+            }
+        }
+        return fieldsToRemove;
+    }
+
+    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('\', \'')+'\']);';
+    }
+
+    determineTitleProperty(columns)
+    {
+        if(columns['label']){
+            return 'label';
+        }
+        if(columns['title']){
+            return 'title';
+        }
+        if(columns['name']){
+            return 'name';
+        }
+        if(columns['key']){
+            return 'key';
+        }
+        return false;
+    }
+
+    generatePropertiesConfig(columns, titleProperty)
+    {
+        let propertiesConfig = [];
+        for(let columnName of Object.keys(columns)){
+            let column = columns[columnName];
+            let propertyKey = titleProperty && titleProperty === columnName ? '[titleProperty]' : columnName;
+            if('id' === columnName){
+                propertiesConfig.push(columnName+': {}');
+                continue;
+            }
+            let props = this.getPropertyAttributes(column);
+            if(0 === props.length){
+                propertiesConfig.push(propertyKey+': {}');
+                continue;
+            }
+            propertiesConfig.push(
+                propertyKey+': {\n                '+props.join(',\n                ')+ '\n            }'
+            );
+        }
+        return propertiesConfig.join(',\n            ');
+    }
+
+    getPropertyAttributes(column)
+    {
+        let props = [];
+        let type = column.type.toLowerCase();
+        this.addTypeAttribute(props, column, type);
+        this.addRequiredAttribute(props, column);
+        return props;
+    }
+
+    addTypeAttribute(props, column, type)
+    {
+        if(column.referencedTable){
+            props.push('type: \'reference\'');
+            props.push('reference: \''+this.getReferenceTable(column)+'\'');
+            return;
+        }
+        if('date' === type || 'datetime' === type || 'timestamp' === type){
+            props.push('type: \'datetime\'');
+            return;
+        }
+        if('text' === type || 'longtext' === type || 'mediumtext' === type || 'tinytext' === type || 'json' === type){
+            props.push('type: \'textarea\'');
+            return;
+        }
+        if('tinyint' === type){
+            props.push('type: \'boolean\'');
+            return;
+        }
+        if('enum' === type){
+            this.addEnumValues(props, column);
+            return;
+        }
+        if(type.includes('int')){
+            props.push('type: \'number\'');
+            return;
+        }
+        if('varchar' === type || 'char' === type){
+            return;
+        }
+        let jsType = TypeMapper.mapDbTypeToJsType(type);
+        if(jsType && 'string' !== jsType){
+            props.push('type: \''+jsType+'\'');
+        }
+    }
+
+    addEnumValues(props, column)
+    {
+        let enumValues = this.parseEnumValues(column.columnType);
+        if(0 === enumValues.length){
+            return;
+        }
+        let availableValues = [];
+        for(let i = 0; i < enumValues.length; i++){
+            availableValues.push('{value: '+(i+1)+', label: \''+enumValues[i]+'\'}');
+        }
+        props.push(
+            'availableValues: [\n                    '+
+            availableValues.join(',\n                    ')+
+            '\n                ]'
+        );
+    }
+
+    parseEnumValues(columnType)
+    {
+        if(!columnType){
+            return [];
+        }
+        let match = columnType.match(/^enum\('(.+)'\)$/i);
+        if(!match){
+            return [];
+        }
+        let valuesString = match[1];
+        return valuesString.split('\',\'');
+    }
+
+    addRequiredAttribute(props, column)
+    {
+        if(!column.nullable && !column.default){
+            props.push('isRequired: true');
+        }
+    }
+
+    getReferenceTable(column)
+    {
+        if(column.referencedTable){
+            return column.referencedTable;
+        }
+        let refTableName = column.name.replace('_id', '');
+        if(refTableName.includes('_')){
+            let parts = refTableName.split('_');
+            if(column.tableName && column.tableName === parts[0]){
+                refTableName = parts.slice(1).join('_');
+            }
+        }
+        return refTableName;
+    }
+
+    getShowPropertiesDeclaration(columns)
+    {
+        let passwordFields = this.getPasswordFields(columns);
+        if(0 === passwordFields.length){
+            return 'let showProperties = propertiesKeys;';
+        }
+        if(1 === passwordFields.length){
+            return 'let showProperties = [...propertiesKeys];\n        showProperties.splice(showProperties.indexOf(\''+
+                passwordFields[0]+
+                '\'), 1);';
+        }
+        return 'let showProperties = sc.removeFromArray([...propertiesKeys], [\''+passwordFields.join('\', \'')+'\']);';
+    }
+
+    getPasswordFields(columns)
+    {
+        let passwordFields = [];
+        for(let columnName of Object.keys(columns)){
+            if('password' === columnName.toLowerCase()){
+                passwordFields.push(columnName);
+            }
+        }
+        return passwordFields;
+    }
+
+    getListPropertiesDeclaration(columns)
+    {
+        let fieldsToRemove = this.getFieldsToRemoveFromList(columns);
+        if(0 === fieldsToRemove.length){
+            return 'let listProperties = propertiesKeys;';
+        }
+        if(1 === fieldsToRemove.length){
+            return 'let listProperties = [...propertiesKeys];\n        listProperties.splice(listProperties.indexOf(\''+
+                fieldsToRemove[0]+
+                '\'), 1);';
+        }
+        return 'let listProperties = sc.removeFromArray([...propertiesKeys], [\''+fieldsToRemove.join('\', \'')+'\']);';
+    }
+
+}
+
+module.exports.EntitiesGeneration = EntitiesGeneration;

package/lib/generators/entities-translations-generation.js

@@ -0,0 +1,135 @@
+/**
+ *
+ * Reldens - EntitiesTranslationsGeneration
+ *
+ */
+
+const { FileHandler } = require('@reldens/server-utils');
+const { Logger, sc } = require('@reldens/utils');
+const { BaseGenerator } = require('./base-generator');
+
+class EntitiesTranslationsGeneration extends BaseGenerator
+{
+
+    constructor(props)
+    {
+        super();
+        this.entitiesTranslationsPath = sc.get(props, 'entitiesTranslationsPath', '');
+        this.templatePath = sc.get(props, 'templatePath', '');
+    }
+
+    generateEntitiesTranslationsFile(generatedEntities, existingEntities, isOverride)
+    {
+        if(isOverride){
+            return this.regenerateEntitiesTranslationsFile(generatedEntities, existingEntities);
+        }
+        return this.appendToEntitiesTranslationsFile(generatedEntities);
+    }
+
+    regenerateEntitiesTranslationsFile(generatedEntities, existingEntities)
+    {
+        if(!FileHandler.exists(this.templatePath)){
+            Logger.critical('Entities translations template file not found: '+this.templatePath);
+            return false;
+        }
+        let translationsTemplateContent = FileHandler.fetchFileContents(this.templatePath);
+        if(!translationsTemplateContent){
+            Logger.critical('Failed to read entities translations template file: '+this.templatePath);
+            return false;
+        }
+        let translationsContent = translationsTemplateContent.replace(
+            /{{labels}}/g,
+            this.getTranslationLabels(Object.assign({}, existingEntities, generatedEntities))
+        );
+        if(!FileHandler.writeFile(this.entitiesTranslationsPath, translationsContent)){
+            Logger.critical('Failed to write entities translations file: '+this.entitiesTranslationsPath);
+            return false;
+        }
+        Logger.info('Regenerated entities translations file: '+this.entitiesTranslationsPath);
+        return true;
+    }
+
+    appendToEntitiesTranslationsFile(generatedEntities)
+    {
+        if(0 === Object.keys(generatedEntities).length){
+            return true;
+        }
+        if(!FileHandler.exists(this.entitiesTranslationsPath)){
+            Logger.info('Entities translations file does not exist, creating new file.');
+            return this.regenerateEntitiesTranslationsFile(generatedEntities, {});
+        }
+        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(generatedEntities)){
+            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 normalizedContent = existingContent.replace(/\s+/g, ' ');
+        let labelsPattern = /labels\s*:\s*\{/;
+        let labelsMatch = normalizedContent.match(labelsPattern);
+        if(!labelsMatch){
+            Logger.error('Could not find labels object in translations file.');
+            return false;
+        }
+        let labelsStart = existingContent.indexOf(labelsMatch[0]);
+        let searchStart = labelsStart + labelsMatch[0].length;
+        let braceCount = 1;
+        let labelsEnd = -1;
+        for(let i = searchStart; i < existingContent.length; i++){
+            if('{' === existingContent[i]){
+                braceCount++;
+            }
+            if('}' === existingContent[i]){
+                braceCount--;
+                if(0 === braceCount){
+                    labelsEnd = i;
+                    break;
+                }
+            }
+        }
+        if(-1 === labelsEnd){
+            Logger.error('Could not find end of labels object.');
+            return false;
+        }
+        let beforeLabelsEnd = existingContent.substring(0, labelsEnd);
+        let contentBeforeEnd = beforeLabelsEnd.trimEnd();
+        let lastChar = contentBeforeEnd[contentBeforeEnd.length - 1];
+        if('{' !== lastChar && ',' !== lastChar){
+            beforeLabelsEnd = contentBeforeEnd + ',';
+        }
+        let updatedContent = beforeLabelsEnd + '\n        ' + newTranslations.join(',\n        ') + existingContent.substring(labelsEnd);
+        if(!FileHandler.writeFile(this.entitiesTranslationsPath, updatedContent)){
+            Logger.error('Failed to append to entities translations file: '+this.entitiesTranslationsPath);
+            return false;
+        }
+        Logger.info('Updated translations file with '+newTranslations.length+' new labels.');
+        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        ');
+    }
+
+}
+
+module.exports.EntitiesTranslationsGeneration = EntitiesTranslationsGeneration;