@blazedpath/commons 0.2.2 → 0.3.1

package/blz-cache/LruCache.js

@@ -1,44 +0,0 @@
-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

@@ -1,29 +0,0 @@
-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

@@ -1,434 +0,0 @@
-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