@blazedpath/commons 0.3.1 → 0.4.0

package/blz-cache/LruCache.js

@@ -0,0 +1,44 @@
+const { LRUCache } = require('lru-cache')
+class LruCache {
+    constructor () {
+      this._cache = new LRUCache({ max: 500, maxSize: 5000, ttl: 1000 * 60 * 60 * 3, sizeCalculation: (value, key) => { return 1 } })
+    }
+  
+    /**
+   * @name set
+   * @api private
+   * @description Maximum age in ms.
+   * @param {*} key key to be cached.
+   * @param {*} value value to be cached.
+   * @param {*} expire Maximum age in ms.
+   */
+    async set (key, value, expire) {
+      this._cache.set(key, value, expire)
+    }
+  
+    /**
+   * @name get
+   * @api private
+   * @description Get the value that was cached.
+   * @param {*} key
+   * @returns
+   */
+    async get (key) {
+      return this._cache.get(key)
+    }
+  
+    /**
+   * @name del
+   * @api private
+   * @description It was removing the value that was in the cache.
+   * @param {*} key
+   * @returns
+   */
+    async del (key) {
+      this._cache.delete(key)
+    }
+  }
+  const lruCache = new LruCache()
+  module.exports = {
+    lruCache
+  }

package/blz-cache/index.js

@@ -0,0 +1,29 @@
+const { lruCache } = require('./LruCache')
+
+module.exports = typeof module.exports === "undefined" ? {} : module.exports;
+/**
+ * Get cache item
+ * @param {string} key - key cache item
+ * @return {any}
+ */
+module.exports.localCacheGet = function( key ) {
+    return lruCache.get(key)
+}
+/**
+ * Remove cache item
+ * @param {string} key - key cache item
+ * @return {any}
+ */
+module.exports.localCacheRemove = function( key ) {
+    lruCache.del(key)
+}
+/**
+ * Set cache item
+ * @param {string} key - key cache item
+ * @param {any} value - value of cache
+ * @param {integer} [expire] - expire time in milliseconds
+ * @return {any}
+ */
+module.exports.localCacheSet = function( key, value, expire ) {
+    lruCache.set(key, value, expire || 0)
+}

package/blz-config/index.js

@@ -0,0 +1,434 @@
+const Path = require('path');
+const Fs = require('fs-extra');
+const {h3lp } = require('h3lp');
+
+
+class BlzConfig {
+
+    constructor() {
+        this._config = null
+    }   
+
+    async initialize(configToOverride = {}, appPath) {
+        if (this._config != null) {
+            console.warn('You are call BlzConfig.initialize multiple times. We will override the config')
+        }
+        this._config = await this.loadConfig(configToOverride, appPath)
+        this.normalizeConfig(this._config)
+        this.validateConfig(this._config)
+    }
+
+    async loadConfig(configToOverride, appPath) {
+
+        // It starts from the system configuration and the properties are added by environment variables
+        const configPath = Path.join(appPath, '../config.json')
+        if (!Fs.existsSync(configPath)) {
+            throw new Error(`${configPath} config file not exists`)
+        }
+
+        let config = JSON.parse(Fs.readFileSync(configPath), 'utf8');
+        config = { ...config, ...configToOverride }
+        let connectionsName = config.connections ? Object.keys(config.connections) : [];
+
+        // look for the .env file within the system or at the solution level.
+        let environmentPath = null
+        if (Fs.existsSync(Path.join(appPath, '../.env'))) {
+            environmentPath = Path.join(appPath, '../.env');
+        }
+        else if (Fs.existsSync(Path.join(appPath, '../../.env'))) {
+            environmentPath = Path.join(appPath, '../../.env');
+        }
+
+        // Check duplicate keys in .env
+        if (environmentPath) {
+            this.checkDuplicateKeysInEnv(environmentPath)
+        }
+
+        // if the .env file exists raise the environment variables from this file
+        if (Fs.existsSync(environmentPath)) {
+            require('dotenv').config({ path: environmentPath });
+        }
+        for (let p in process.env) {
+            if (p.startsWith('blz_')) {
+                if (p.startsWith('blz_' + config.name + '_param_') && p.endsWith('_user') && p !== 'blz_' + config.name + '_param_user') {
+                    let name = p.replace('blz_' + config.name + '_param_', '');
+                    name = name.substring(0, name.length - 5);
+                    if (!config.parameters) config.parameters = {};
+                    if (!config.parameters[name]) config.parameters[name] = {};
+                    config.parameters[name].user = this.getValue(process.env[p]);
+                }
+                else if (p.startsWith('blz_' + config.name + '_param_') && p.endsWith('_password') && p !== 'blz_' + config.name + '_param_password') {
+                    let name = p.replace('blz_' + config.name + '_param_', '');
+                    name = name.substring(0, name.length - 9);
+                    if (!config.parameters) config.parameters = {};
+                    if (!config.parameters[name]) config.parameters[name] = {};
+                    config.parameters[name].password = this.getValue(process.env[p]);
+                }
+                else if (p.startsWith('blz_' + config.name + '_param_')) {
+                    let name = p.replace('blz_' + config.name + '_param_', '');
+                    if (!config.parameters) config.parameters = {};
+                    if (!config.visibleParameters) config.visibleParameters = {};
+                    const format = config.configParameters && config.configParameters[name] ? config.configParameters[name].format : null;
+                    const hidden = config.configParameters && config.configParameters[name] ? config.configParameters[name].hidden : false;
+                    try {
+                        const value = this.getFormatValue(process.env[p], format);
+                        config.parameters[name] = value;
+                        if (hidden!== true) {
+                            config.visibleParameters[name] = value;
+                        }  
+                    }
+                    catch (error) {
+                        throw new Error(`Error: Bad value for parameter "${p}" defined in the environment.\n- ${error.message}`)
+                    }
+                }
+                else if (p.startsWith('blz_' + config.name + '_auth_')) {
+                    let name = p.replace('blz_' + config.name + '_auth_', '');
+                    if (!config.authServer) config.authServer = {};
+                    config.authServer[name] = this.getValue(process.env[p]);
+                }
+                else if (p === 'blz_' + config.name + '_enableKafkaConsumers') {
+                    const enableKafkaConsumersValue = this.getValue(process.env[p]) || ''
+                    const enableKafkaConsumers = enableKafkaConsumersValue
+                        .trim()
+                        .split(',')
+                        .filter(Boolean)
+                        .map(consumerName => consumerName.trim())
+                    const enableKafkaConsumersUniq = [... new Set(enableKafkaConsumers)]
+                    config.enableKafkaConsumers = enableKafkaConsumersUniq
+                }
+                else if (p.startsWith('blz_' + config.name + '_')) {
+                    let name = p.replace('blz_' + config.name + '_', '');
+                    config[name] = this.getValue(process.env[p]);
+                }
+                else {
+                    let str = p.replace('blz_', '');
+                    let index = str.indexOf('_');
+                    let name = str.substring(0, index);
+                    if (connectionsName.includes(name)) {
+                        let paramName = str.replace(name + '_', '');
+                        config.connections[name][paramName] = this.getValue(process.env[p]);
+                    } else {
+                        config[p] = this.getValue(process.env[p]);
+                    }
+                }
+            }
+        }
+        // set internal parameters
+       	this.setAliasParams(config)
+        return config;
+    }
+
+    setAliasParams(config){
+        if (config.parameters?.SecurityApiSanitizeSqlInjection) {
+            config.blz_securityApiSanitizeSqlInjection = config.parameters.SecurityApiSanitizeSqlInjection
+            process.env.blz_securityApiSanitizeSqlInjection = config.parameters.SecurityApiSanitizeSqlInjection
+        }
+        if (config.parameters?.SecurityApiSanitizeOnlyLog) {
+            process.env.blz_securityApiSanitizeOnlyLog = config.parameters.SecurityApiSanitizeOnlyLog
+        }
+        if (config.parameters?.SecurityExcludeSanitizePaths) {
+            process.env.blz_securityExcludeSanitizePaths = config.parameters.SecurityExcludeSanitizePaths
+        }
+        if (config.parameters?.SecurityApiSanitizeDangerousParamPatterns) {
+            process.env.blz_securityApiSanitizeDangerousParamPatterns = config.parameters.SecurityApiSanitizeDangerousParamPatterns
+        }
+        if (config.parameters?.SecurityApiSanitizeDangerousSqlPatterns) {
+            process.env.blz_securityApiSanitizeDangerousSqlPatterns = config.parameters.SecurityApiSanitizeDangerousSqlPatterns
+        }
+        if (config.parameters?.SecurityApiSanitizeAllowedSqlInputPatterns ) {
+            process.env.blz_securityApiSanitizeAllowedSqlInputPatterns = config.parameters.SecurityApiSanitizeAllowedSqlInputPatterns
+        }
+        if (config.parameters?.SecurityApiSanitizeAllowedInputPatterns  ) {
+            process.env.blz_securityApiSanitizeAllowedInputPatterns = config.parameters.SecurityApiSanitizeAllowedInputPatterns
+        }
+        if (config.parameters?.HttpRequestLimiterTimeframe) {
+            config.httpRequestLimiterTimeframe= config.parameters.HttpRequestLimiterTimeframe
+        }
+        if (config.parameters?.HttpRequestLimiterCount) {
+            config.httpRequestLimiterCount = config.parameters.HttpRequestLimiterCount
+        }
+        if (config.parameters?.HttpRequestLimiterAddressOnly !== undefined) {
+            config.httpRequestLimiterAddressOnly = config.parameters.HttpRequestLimiterAddressOnly;
+        }
+        if (config.parameters?.HttpRequestLimiterTrustProxy !== undefined) {
+            config.httpRequestLimiterTrustProxy = config.parameters.HttpRequestLimiterTrustProxy;
+        }
+        if (process.env.blz_secureUrlCookieKey  ) { 
+            config.parameters.SecureUrlCookieKey = process.env.blz_secureUrlCookieKey
+        }
+        if (process.env.blz_secureUrlTimeoutMs  ) { 
+            config.parameters.SecureUrlTimeoutMs = process.env.blz_secureUrlTimeoutMs
+        }
+    }
+
+    checkDuplicateKeysInEnv(environmentPath) {
+        const env = Fs.readFileSync(environmentPath, 'utf8');
+        const lines = env.split('\n');
+        const keys = [];
+        const duplicateKeys = [];
+        lines.forEach((line) => {
+            line = line.trim();
+            if (line === '' || line.startsWith('#'))
+                return;
+            const [key] = line.split('=');
+            if (keys.includes(key)) {
+                duplicateKeys.push(key);
+            }
+            keys.push(key);
+        });
+        if (duplicateKeys.length > 0) {
+            throw new Error(`Error. Duplicate keys in .env file: ${JSON.stringify([...new Set(duplicateKeys)])}`);
+        }
+    }
+
+    getValue(value) {
+        if (value === null) {
+            return null;
+        }
+        if (typeof value === 'string') {
+            if (value.toLocaleLowerCase().trim() === 'false') {
+                return false;
+            }
+            if (value.toLocaleLowerCase().trim() === 'true') {
+                return true;
+            }
+            let resultValue = value;
+            let indexStart = resultValue.indexOf('${');
+            let indexEnd = -1;
+            if (indexStart > -1) {
+                indexEnd = resultValue.indexOf('}', indexStart);
+            }
+            while (indexStart > -1 && indexEnd > indexStart) {
+                resultValue =
+                    resultValue.substring(0, indexStart) +
+                    process.env[resultValue.substring(indexStart + 2, indexEnd)] +
+                    resultValue.substring(indexEnd + 1, resultValue.length);
+                indexStart = resultValue.indexOf('${');
+                indexEnd = -1;
+                if (indexStart > -1) {
+                    indexEnd = resultValue.indexOf('}', indexStart);
+                }
+            }
+            return resultValue;
+        }
+        return value;
+    }
+
+    getFormatValue(value, format) {
+        if (value == null) {
+            return null;
+        }
+        if (!format) {
+            return this.getValue(value);
+        }
+        switch (format) {
+            case 'String': {
+                return this.getValue(value);
+            }
+            case 'Numeric': {
+                const numericValue = Number(value);
+                if (isNaN(numericValue)) {
+                    throw new Error(`Invalid Numeric value. Detected: "${value}"`);
+                }
+                return parseFloat(value);
+            }
+            case 'Boolean': {
+                const boolValue = value.toLocaleLowerCase().trim();
+                if (!['true', 'false'].includes(boolValue)) {
+                    throw new Error(`Invalid Boolean value (only allowed "true" or "false"). Detected: "${value}"`);
+                }
+                return boolValue === 'true';
+            }
+            default: {
+                return value;
+            }
+        }
+    }
+
+    normalizeConfig(config = {}) {
+        for (const p in config.connections) {
+            const connection = config.connections[p];
+            if (connection.type === "Mongodb") {
+                const hasOldFormat = Boolean(connection.database && connection.database.trim());
+                const hasNewFormat = Boolean(connection.databaseName && connection.databaseName.trim());
+                const hasToWarnAboutConfusion = hasOldFormat && hasNewFormat;
+                const hasToUpdate = hasOldFormat && !hasNewFormat;
+
+                if (hasToWarnAboutConfusion) {
+                    console.warn(`Warning: Your are using the old format ("blz_${p}_database") and the new format ("blz_${p}_databaseName"). We will use the new one ("blz_${p}_databaseName"). Please, consider to remove the old format to avoid confusion.`);
+                    delete connection.database;
+                }
+                if (hasToUpdate) {
+                    console.warn(`Warning: Your are using the "blz_${p}_database" variable, but you need to use "blz_${p}_databaseName" instead. Environment variables for MongoDb databases with "blz_xxx_database" format may will disappear in the future. Please, update it.`);
+                    connection.databaseName = connection.database;
+                    delete connection.database;
+                }
+            } else if(connection.type === "Kafka")  {
+                connection.requestTimeout = this.validateOrConvertToNumber(connection.requestTimeout, 'requestTimeout', 30000);
+                connection.connectionTimeout = this.validateOrConvertToNumber(connection.connectionTimeout, 'connectionTimeout', 3000);
+                connection.connectionRetries = this.validateOrConvertToNumber(connection.connectionRetries, 'connectionRetries', 3);
+                connection.connectionInitialRetryTime = this.validateOrConvertToNumber(connection.connectionInitialRetryTime, 'connectionInitialRetryTime', 3000);
+                connection.connectionMaxRetryTime = this.validateOrConvertToNumber(connection.connectionMaxRetryTime, 'connectionMaxRetryTime', 60000);
+                connection.connectionRetryFactor = this.validateOrConvertToNumber(connection.connectionRetryFactor, 'connectionRetryFactor', 1.5);
+            }           
+        }
+    }
+
+    validateOrConvertToNumber(value,name, defaultValue) {
+        if (value === undefined || value === null) { 
+            return defaultValue; 
+        }        
+        if (typeof value === 'string' && h3lp.val.isNumber(value)){
+            return h3lp.val.isDecimal(value)?parseFloat(value): Path.parse(value);
+        } else if (typeof value === 'number'){
+            return connection.requestTimeout;
+        } else {
+            throw new Error(`Error: ${name} ${value} not supported`);
+        }
+    }
+
+    validateConfig(config) {
+        if (config === undefined) {
+            throw new Error(`Error: config not found`);
+        }
+        if (config.type === undefined) {
+            throw new Error(`Error: config type undefined`);
+        }
+        if (config.name === undefined) {
+            throw new Error(`Error: config name undefined`);
+        }
+        //validate application config
+        switch (config.type) {
+            case "Microservice":
+            case "ProcessEngine":
+            case "RestApi":
+                if (config.port === undefined) {
+                    throw new Error(`Error: Environment variable blz_${config.name}_port is required`);
+                }
+                break;
+            case "Mongodb":
+            case "RelationalDatabase":
+            case "BeeAuthServer":
+            case "SmtpServer":
+            case "WebFrontend":
+            case "MobileApp":
+            case "Custom":
+                break;
+            default:
+                throw new Error(`Error: type ${config.type} not supported`);
+        }
+        //validate connections config
+        if (config.connections !== undefined) {
+            for (const p in config.connections) {
+                const connection = config.connections[p];
+                switch (connection.type) {
+                    case "Microservice":
+                    case "ProcessEngine":
+                    case "RestApi":
+                        if (connection.url === undefined || connection.url.trim() === "") {
+                            throw new Error(`Error: Environment variable blz_${p}_url is required`);
+                        }
+                        break;
+                    case "Mongodb":
+                        if (connection.url === undefined || connection.url.trim() === "") {
+                            throw new Error(`Error: Environment variable blz_${p}url is required`);
+                        }
+                        if (connection.databaseName === undefined || connection.databaseName.trim() === "") {
+                            throw new Error(`Error: Environment variable blz_${p}_databaseName is required`);
+                        }
+                        break;
+                    case "RelationalDatabase":
+                        if (connection.providerName === undefined || connection.providerName.trim() === "") {
+                            throw new Error(`Error: Environment variable blz_${p}_providerName is required`);
+                        }
+                        if (connection.customUrl) {
+                            if (connection.protocol === undefined || connection.protocol.trim() === "") {
+                                throw new Error(`Error: Environment variable blz_${p}_protocol is required`);
+                            }
+                            if (connection.url === undefined || connection.url.trim() === "") {
+                                throw new Error(`Error: Environment variable blz_${p}_url is required`);
+                            }
+                        } else {
+                            if (connection.providerName === 'Oracle') {
+                                if (connection.dataSource === undefined || connection.dataSource.trim() === "") {
+                                    throw new Error(`Error: Environment variable blz_${p}_dataSource is required`);
+                                }
+                            } else {
+                                if (connection.host === undefined || connection.host.trim() === "") {
+                                    throw new Error(`Error: Environment variable blz_${p}_host is required`);
+                                }
+                                if (connection.port === undefined || connection.port.trim() === "") {
+                                    throw new Error(`Error: Environment variable blz_${p}_port is required`);
+                                }
+                                if (connection.database === undefined || connection.database.trim() === "") {
+                                    throw new Error(`Error: Environment variable blz_${p}_database is required`);
+                                }
+                            }
+                            if (connection.user === undefined || connection.user.trim() === "") {
+                                throw new Error(`Error: Environment variable blz_${p}_user is required`);
+                            }
+                            if (connection.password === undefined || connection.password.trim() === "") {
+                                throw new Error(`Error: Environment variable blz_${p}_password is required`);
+                            }
+                        }
+                        break;
+                    case "Redis":
+                    case "Hazelcast":
+                        if (connection.providerName === undefined || connection.providerName.trim() === "") {
+                            throw new Error(`Error: Environment variable blz_${p}_providerName is required`);
+                        }
+                        if (connection.host === undefined || connection.host.trim() === "") {
+                            throw new Error(`Error: Environment variable blz_${p}_host is required`);
+                        }
+                        if (connection.port === undefined || connection.port.trim() === "") {
+                            throw new Error(`Error: Environment variable blz_${p}_port is required`);
+                        }
+                        if (connection.database === undefined || connection.database.trim() === "") {
+                            throw new Error(`Error: Environment variable blz_${p}_database is required`);
+                        }
+                        if (connection.password === undefined || connection.password.trim() === "") {
+                            throw new Error(`Error: Environment variable blz_${p}_password is required`);
+                        }
+                        break;
+                }
+            }
+        }
+        //validate configParameters config
+        if (config.configParameters !== undefined) {
+            for (const p in config.configParameters) {
+                const configParameter = config.configParameters[p];
+                switch (configParameter.format) {
+                    case "String":
+                    case "Numeric":
+                    case "Json":
+                    case "Boolean":
+                        if (config.parameters[p] === undefined) {
+                            throw new Error(`Error: Environment variable blz_${config.name}_param_${p} is required`);
+                        }
+                        break;
+                    case "Credentials":
+                        if (config.parameters[p + '_user'] === undefined) {
+                            throw new Error(`Error: Environment variable blz_${config.name}_param_${p}_user is required`);
+                        }
+                        if (config.parameters[p + '_password'] === undefined) {
+                            throw new Error(`Error: Environment variable blz_${config.name}_param_${p}_password is required`);
+                        }
+                        break;
+                    default:
+                        throw new Error(`Error: parameter ${p} format ${configParameter.format} not supported`);
+                }
+            }
+        }
+    }
+
+    getConfig() {
+        return this._config
+    }
+
+    setConfig(config = {}) {
+        this.setAliasParams(config)
+        this._config = { ...config }
+    }
+}
+const blzConfig = new BlzConfig()
+module.exports = blzConfig