@blazedpath/commons 0.0.4

package/blz-rds-postgres/syntaxis.json

@@ -0,0 +1,114 @@
+{
+    "selectWithPaging1": "SELECT * FROM (SELECT %1$s) AS TMP LIMIT %4$s",
+    "selectWithPagingN": "SELECT * FROM (SELECT %1$s) AS TMP LIMIT %4$s OFFSET %2$s",
+    "insertAutoIncremental": "INSERT INTO %1$s (%3$s, %4$s) VALUES (nextval('%2$s'), %5$s) RETURNING %3$s AS scalaroutput",
+    "insertConditional":"INSERT INTO %1$s (%4$s)\r\nSELECT %5$s\r\nWHERE NOT EXISTS (SELECT 1 FROM %1$s WHERE %6$s)\r\nRETURNING %3$s AS scalaroutput",
+    "insertConditionalAutoIncremental":"INSERT INTO %1$s (%3$s, %4$s)\r\nSELECT nextval('%2$s'), %5$s\r\nWHERE NOT EXISTS (SELECT 1 FROM %1$s WHERE %6$s)\r\nRETURNING %3$s AS scalaroutput",
+    "selectExists": "SELECT CASE WHEN %1$s THEN 1 ELSE 0 END",
+    "executeStoredProcedure": "call %1$s(%2$s)",
+    "procedureResultSet": "explicit",
+    "core" : {
+        "asc": "%1$s ASC NULLS FIRST",
+        "avg": "ROUND(AVG(%1$s), 8)",
+        "count": "COUNT(%1$s)",
+        "countDistinct": "COUNT(DISTINCT %1$s)",
+        "desc": "%1$s DESC NULLS LAST",
+        "distinct": "DISTINCT %1$s",
+        "divide" : "(%1$s::decimal / %2$s::decimal)",
+        "false" : "false",
+        "isNotNull": "(%1$s IS NOT NULL)",
+        "isNull": "(%1$s IS NULL)",
+        "like": "(%1$s LIKE %2$s)",
+        "max": "MAX(%1$s)",
+        "min": "MIN(%1$s)",
+        "nvl": "COALESCE(%1$s, %2$s)",
+        "parameter": ":%1$s",
+        "remainder": "MOD(%1$s,%2$s)",
+        "sum": "SUM(%1$s)",
+        "true" : "true"
+    },
+    "datetimes" : {
+        "addDays": "%1$s + %2$s * INTERVAL '1 DAY'",
+        "addHours":  "%1$s + %2$s * INTERVAL '1 HOUR'",
+        "addMilliseconds": "%1$s + %2$s * INTERVAL '1 MILLISECONDS'",
+        "addMinutes": "%1$s + %2$s * INTERVAL '1 MINUTE'",
+        "addMonths": "%1$s + %2$s * INTERVAL '1 MONTH'",
+        "addSeconds": "%1$s + %2$s * INTERVAL '1 SECOND'",
+        "addYears": "%1$s + %2$s * INTERVAL '1 YEAR'",
+        "date": "TO_TIMESTAMP('%1$s-%2$s-%3$s 0:0:0', 'YYYY-MM-DD HH24:MI:SS')",
+        "dateDiff": "DATE_PART('day', (%1$s) - (%2$s))",
+        "datetime": "TO_TIMESTAMP('%1$s-%2$s-%3$s %4$s:%5$s:%6$s', 'YYYY-MM-DD HH24:MI:SS')",
+        "datetimeDiff": "(((DATE_PART('day', %1$s - %2$s) * 24 + DATE_PART('hour', %1$s - %2$s)) * 60 + DATE_PART('minute', %1$s - %2$s)) * 60 + DATE_PART('second', %1$s - %2$s)) * 1000",
+        "day": "DATE_PART('day', %1$s)",
+        "hour": "DATE_PART('hour', %1$s)",
+        "millisecond": "DATE_PART('millisecond', %1$s)",
+        "minute": "DATE_PART('minute', %1$s)",
+        "month": "DATE_PART('month', %1$s)",
+        "monthText": "TRIM(TO_CHAR(%1$s, 'Month'))",
+        "now": "CURRENT_TIMESTAMP at time zone 'UTC'",
+        "second": "DATE_PART('second', %1$s)",
+        "subtractDays": "%1$s - %2$s * INTERVAL '1 DAY'",
+        "subtractHours":  "%1$s - %2$s * INTERVAL '1 HOUR'",
+        "subtractMilliseconds": "%1$s - %2$s * INTERVAL '1 MILLISECONDS'",
+        "subtractMinutes": "%1$s - %2$s * INTERVAL '1 MINUTE'",
+        "subtractSeconds": "%1$s - %2$s * INTERVAL '1 SECOND'",
+        "today": "CURRENT_DATE",
+        "time": "CAST(TO_TIMESTAMP('2018-1-1 %1$s:%2$s:%3$s', 'YYYY-MM-DD HH24:MI:SS') AS time)",
+        "timeDiff": "(((DATE_PART('hour', %1$s - %2$s)) * 60 + DATE_PART('minute', %1$s - %2$s)) * 60 + DATE_PART('second', %1$s - %2$s)) * 1000",
+        "week": "DATE_PART('week', %1$s)",
+        "weekDay": "DATE_PART('dow', %1$s)",
+        "weekDayText": "TRIM(TO_CHAR(%1$s,'Day'))",
+        "year": "DATE_PART('year', %1$s)"
+    },
+    "math" : {
+        "abs": "ABS(%1$s)",
+        "acos": "ACOS(%1$s)",
+        "asin": "ASIN(%1$s)",
+        "atan": "ATAN(%1$s)",
+        "atan2": "ATAN2(%2$s,%1$s)",
+        "ceil": "CEIL(%1$s)",
+        "cos": "COS(%1$s)",
+        "cosh": "((EXP(%1$s) + EXP(%1$s*-1))/2)",
+        "exp": "EXP(%1$s)",
+        "floor": "FLOOR(%1$s)",
+        "logBase": "LOG(%2$s,%1$s)",
+        "log": "LOG(EXP(1),%1$s)",
+        "log10": "LOG(10, %1$s)",
+        "pow": "POWER(%1$s,%2$s)",
+        "random": "RANDOM()",
+        "remainder": "MOD(%1$s,%2$s)",
+        "round": "ROUND(%1$s,0)",
+        "roundWithDecimals": "ROUND(%1$s,%2$s)",
+        "sign": "SIGN(%1$s)",
+        "sin": "SIN(%1$s)",
+        "sinh": "((EXP(%1$s) - EXP(%1$s*-1))/2)",
+        "sqrt": "SQRT(%1$s)",
+        "tan": "TAN(%1$s)",
+        "tanh": "(EXP(%1$s) - EXP(%1$s*-1))/(EXP(%1$s) + EXP(%1$s*-1))",
+        "trunc": "TRUNC(CAST(%1$s AS numeric),0)",
+        "truncWithDecimals": "TRUNC(CAST(%1$s AS numeric),CAST(%2$s AS int))"
+    },
+    "strings": {
+        "concat": "CONCAT_WS('',{[,]})",
+        "contains": "(POSITION(%2$s IN %1$s) IS NOT NULL AND POSITION(%2$s IN %1$s) > 0)",
+        "endsWith": "(%1$s LIKE CONCAT('%%',%2$s))",
+        "indexOf": "CASE WHEN POSITION(%2$s in %1$s) IS NULL THEN -1 WHEN POSITION(%2$s in %1$s) = 0 THEN -1 ELSE POSITION(%2$s in %1$s) - 1 END",
+        "isNullOrEmpty": "(%1$s IS NULL OR %1$s = '')",
+        "isNullOrWhiteSpace": "(%1$s IS NULL OR TRIM(%1$s) = '')",
+        "join": "CONCAT_WS(%1$s,{[,]})",
+        "lastIndexOf": "CASE WHEN (POSITION(REVERSE(%2$s) IN REVERSE(%1$s)) = 0) IS NULL THEN - 1 WHEN (POSITION(REVERSE(%2$s) IN REVERSE(%1$s)) = 0) THEN -1 ELSE POSITION(REVERSE(%2$s) IN REVERSE(%1$s)) - 1 + LENGTH(%1$s) - LENGTH(%2$s) END",
+        "length": "CASE WHEN %1$s IS NULL THEN 0 ELSE LENGTH(%1$s) END",
+        "padLeft": "LPAD(%1$s,%2$s,' ')",
+        "padLeftPattern": "LPAD(%1$s,%2$s,%3$s)",
+        "padRight": "RPAD(%1$s,%2$s,' ')",
+        "padRightPattern": "RPAD(%1$s,%2$s,%3$s)",
+        "replace": "REPLACE(%1$s,%2$s,%3$s)",
+        "startsWith": "(%1$s LIKE CONCAT(%2$s,'%%'))",
+        "substring": "SUBSTR(%1$s,%2$s+1,%3$s)",
+        "toLower": "LOWER(%1$s)",
+        "toUpper": "UPPER(%1$s)",
+        "trim": "TRIM(%1$s)",
+        "trimEnd": "RTRIM(%1$s)",
+        "trimStart": "LTRIM(%1$s)"
+    }
+}

package/blz-redis/index.js

@@ -0,0 +1,217 @@
+const redisCache = require('./lib/redisCache.js');
+const fs = require('fs-extra');
+
+// Redis Client cache
+let redisClients = {};
+
+// Gets a Redis Client by connection name
+function getOrCreateRedisClient(connection) {
+    let redisClient = redisClients[connection.name];
+    if (redisClient) {
+        return redisClient;
+    }
+
+    let options = {
+        connectionName: connection.name,
+        connectionOptions: { autoPipelining: true },
+        clusterMode: connection.clusterMode,
+        nodes: ensureNodes(connection.nodes),
+        pool: true,
+        poolMin: connection.poolMin,
+        poolMax: connection.poolMax,
+        poolKeepAlive: connection.poolKeepAlive,
+        poolAcquireTimeout: connection.poolAcquireTimeout,
+        poolRetryDelay: connection.poolRetryDelay
+    };
+    if (connection.host != null) {
+        options.connectionOptions.host = connection.host;
+    }
+    if (connection.port != null) {
+        options.connectionOptions.port = connection.port;
+    }
+    if (connection.db != null) {
+        options.connectionOptions.db = connection.db;
+    }
+    if (connection.tls) {
+        options.connectionOptions.tls = {};
+        if (connection.key) {
+            options.connectionOptions.tls.key = fs.readFileSync(connection.key);
+        }
+        if (connection.cert) {
+            options.connectionOptions.tls.cert = fs.readFileSync(connection.cert);
+        }
+        if (connection.ca) {
+            options.connectionOptions.tls.ca = fs.readFileSync(connection.ca);
+        }
+        if (connection.servername) {
+            options.connectionOptions.tls.servername = connection.servername;
+        }
+        if (!connection.rejectUnauthorized) {
+            options.connectionOptions.tls.rejectUnauthorized = false;
+        }
+    }
+    if (connection.user != null) {
+        options.connectionOptions.username = connection.user;
+    }
+    if (connection.password != null) {
+        options.connectionOptions.password = connection.password;
+    }
+    redisClient = redisCache.createRedisClient(options);
+    redisClients[connection.name] = redisClient;
+    return redisClient;
+}
+
+function ensureNodes(nodes) {
+    if (nodes) {
+        if (!Array.isArray(nodes)) {
+            if (typeof (nodes) === 'string') {
+                let nodes = nodes.split(',');
+                const arr = [];
+                for (let i = 0; i < nodes.length; i++) {
+                    const obj = {};
+                    let nodeInfo = nodes.split('@');
+                    if (nodeInfo.length > 1) {
+                        let auth = nodeInfo[0].split(':');
+                        if (auth.length > 1) {
+                            obj.username = auth[0];
+                        }
+                        obj.password = (obj.username) ? auth[1] : auth[0];
+                    }
+                    let host = (nodeInfo.length > 1) ? nodeInfo[1].split(':') : nodeInfo[0].split(':');
+                    obj.host = host[0];
+                    obj.port = host[1];
+                    arr.push(obj);
+                }
+                return arr;
+            }
+        }
+    }
+    return nodes;
+}
+
+module.exports = {
+    redisGet: function (connection, key) {
+        let redisClient = getOrCreateRedisClient(connection);
+        return redisClient.get(key);
+    },
+    redisMget: function (connection, keys) {
+        let redisClient = getOrCreateRedisClient(connection);
+        return redisClient.mget(keys);
+    },
+    redisSet: function (connection, key, value) {
+        let redisClient = getOrCreateRedisClient(connection);
+        return redisClient.set(key, value);
+    },
+    redisSetex: function (connection, key, ttl, value) {
+        let redisClient = getOrCreateRedisClient(connection);
+        return redisClient.setex(key, ttl, value);
+    },
+    redisMset: function (connection, data) {
+        let redisClient = getOrCreateRedisClient(connection);
+        return redisClient.mset(data);
+    },
+    redisDel: function (connection, key) {
+        let redisClient = getOrCreateRedisClient(connection);
+        return redisClient.del(key);
+    },
+    redisExpire: function (connection, key, ttl) {
+        let redisClient = getOrCreateRedisClient(connection);
+        return redisClient.expire(key, ttl);
+    },
+    redisTtl: function (connection, key) {
+        let redisClient = getOrCreateRedisClient(connection);
+        return redisClient.ttl(key);
+    },
+    redisExists: function (connection, key) {
+        let redisClient = getOrCreateRedisClient(connection);
+        return redisClient.exists(key);
+    },
+    redisKeys: function (connection, pattern) {
+        let redisClient = getOrCreateRedisClient(connection);
+        return redisClient.keys(pattern);
+    },
+    redisDbsize: function (connection) {
+        let redisClient = getOrCreateRedisClient(connection);
+        return redisClient.dbsize();
+    },
+    redisHget: function (connection, key, field) {
+        let redisClient = getOrCreateRedisClient(connection);
+        return redisClient.hget(key, field);
+    },
+    redisHmget: function (connection, key, fields) {
+        let redisClient = getOrCreateRedisClient(connection);
+        return redisClient.hmget(key, fields);
+    },
+    redisHset: function (connection, key, field, value) {
+        let redisClient = getOrCreateRedisClient(connection);
+        return redisClient.hset(key, field, value);
+    },
+    redisHmset: function (connection, key, data) {
+        let redisClient = getOrCreateRedisClient(connection);
+        return redisClient.hmset(key, data);
+    },
+    redisHdel: function (connection, key, field) {
+        let redisClient = getOrCreateRedisClient(connection);
+        return redisClient.hdel(key, field);
+    },
+    redisHexists: function (connection, key, field) {
+        let redisClient = getOrCreateRedisClient(connection);
+        return redisClient.hexists(key, field);
+    },
+    redisHkeys: function (connection, key) {
+        let redisClient = getOrCreateRedisClient(connection);
+        return redisClient.hkeys(key);
+    },
+    redisHvals: function (connection, key) {
+        let redisClient = getOrCreateRedisClient(connection);
+        return redisClient.hvals(key);
+    },
+    redisHgetall: function (connection, key) {
+        let redisClient = getOrCreateRedisClient(connection);
+        return redisClient.hgetall(key);
+    },
+    redisHlen: function (connection, key) {
+        let redisClient = getOrCreateRedisClient(connection);
+        return redisClient.hlen(key);
+    },
+    redisLindex: function (connection, key, index) {
+        let redisClient = getOrCreateRedisClient(connection);
+        return redisClient.lindex(key, index);
+    },
+    redisLpop: function (connection, key, count) {
+        let redisClient = getOrCreateRedisClient(connection);
+        return redisClient.lpop(key, count);
+    },
+    redisRpop: function (connection, key, count) {
+        let redisClient = getOrCreateRedisClient(connection);
+        return redisClient.rpop(key, count);
+    },
+    redisLset: function (connection, key, index, element) {
+        let redisClient = getOrCreateRedisClient(connection);
+        return redisClient.lset(key, index, element);
+    },
+    redisLpush: function (connection, key, element) {
+        let redisClient = getOrCreateRedisClient(connection);
+        return redisClient.lpush(key, element);
+    },
+    redisRpush: function (connection, key, element) {
+        let redisClient = getOrCreateRedisClient(connection);
+        return redisClient.rpush(key, element);
+    },
+    redisLlen: function (connection, key) {
+        let redisClient = getOrCreateRedisClient(connection);
+        return redisClient.llen(key);
+    },
+    redisFlushdb: function (connection) {
+        let redisClient = getOrCreateRedisClient(connection);
+        return redisClient.flushdb();
+    },
+    redisFlushall: function (connection) {
+        let redisClient = getOrCreateRedisClient(connection);
+        return redisClient.flushall();
+    },
+    redisPing: function (connection) {
+        let redisClient = getOrCreateRedisClient(connection);
+        return redisClient.ping();
+    }
+};

package/blz-redis/lib/redisCache.js

@@ -0,0 +1,265 @@
+const Redis = require('ioredis');
+const genericPool = require('generic-pool');
+
+// Connection Pool cache
+let poolsByName = {};
+
+function createRedisClient(config) {
+    return {
+        get: function(key) {
+            return send(config, 'get', key);
+        },
+        mget: function(keys) {
+            return send(config, 'mget', keys);
+        },
+        set: function(key, value) {
+            return send(config, 'set', key, value);
+        },
+        setex: function(key, ttl, value) {
+            return send(config, 'setex', key, ttl, value);
+        },
+        mset: function(data) {
+            return send(config, 'mset', data);
+        },
+        del: function(key) {
+            return send(config, 'del', key);
+        },
+        expire: function(key, ttl) {
+            return send(config, 'expire', key, ttl);
+        },
+        ttl: function(key) {
+            return send(config, 'ttl', key);
+        },
+        exists: function(key) {
+            return send(config, 'exists', key);
+        },
+        keys: function(pattern) {
+            return send(config, 'keys', pattern);
+        },
+        dbsize: function() {
+            return send(config, 'dbsize');
+        },
+        hget: function(key, field) {
+            return send(config, 'hget', key, field);
+        },
+        hmget: function(key, fields) {
+            return send(config, 'hmget', key, fields);
+        },
+        hset: function(key, field, value) {
+            return send(config, 'hset', key, field, value);
+        },
+        hmset: function(key, data) {
+            return send(config, 'hmset', key, data);
+        },
+        hdel: function(key, field) {
+            return send(config, 'hdel', key, field);
+        },
+        hexists: function(key, field) {
+            return send(config, 'hexists', key, field);
+        },
+        hkeys: function(key) {
+            return send(config, 'hkeys', key);
+        },
+        hvals: function(key) {
+            return send(config, 'hvals', key);
+        },
+        hgetall: function(key) {
+            return send(config, 'hgetall', key);
+        },
+        hlen: function(key) {
+            return send(config, 'hlen', key);
+        },
+        lindex: function(key, index) {
+            return send(config, 'lindex', key, index);
+        },
+        lpop: function(key, count) {
+            if (count) {
+                return send(config, 'lpop', key, count);
+            } else {
+                return send(config, 'lpop', key);
+            }
+        },
+        rpop: function(key, count) {
+            if (count) {
+                return send(config, 'rpop', key, count);
+            } else {
+                return send(config, 'rpop', key);
+            }
+        },
+        lset: function(key, index, element) {
+            return send(config, 'lset', key, index, element);
+        },
+        lpush: function(key, element) {
+            return send(config, 'lpush', key, element);
+        },
+        rpush: function(key, element) {
+            return send(config, 'rpush', key, element);
+        },
+        llen: function(key) {
+            return send(config, 'llen', key);
+        },
+        flushdb: async function() {
+            send(config, 'flushdb');
+        },
+        flushall: async function() {
+            send(config, 'flushall');
+        },
+        ping: async function() {
+            await send(config, 'ping');
+            return true;
+        }
+    }
+}
+
+async function getConnection(config) {
+    if (!config.pool) {
+        return createConnection(config);
+    }
+    try {
+        return await getPool(config).acquire();
+    } catch (err) {
+        throw error('RedisPoolAcquireError', { connectionName: config.connectionName }, err);
+    }
+}
+
+function createConnection(config) {
+    return new Promise(function(resolve, reject) {
+        config.connectionOptions.retryStrategy = function (times) {
+            return null;
+        };
+        let redisClient = (!config.clusterMode)
+            ? new Redis(config.connectionOptions)
+            : new Redis.Cluster(config.nodes, { redisOptions: config.connectionOptions });
+        redisClient.pool = config.pool;
+        redisClient.connectionName = config.connectionName;
+        // listen for redis connection events
+        redisClient.on('error', err => {
+            // handle error here
+            redisClient.active = false;
+            reject(error('RedisConnectionError', { connectionName: config.connectionName }, err));
+        });
+
+        redisClient.on('close', () => {
+            redisClient.active = false;
+        });
+
+        redisClient.on('ready', () => {
+            redisClient.active = true;
+            resolve(redisClient);
+        });
+    });
+}
+
+async function send(config, command, ...args) {
+    let connection = null;
+    try {
+        connection = await getConnection(config);
+        return await executeCommand(connection, command, ...args);
+    } catch (err) {
+        throw error('RedisError', null, err);
+    } finally {
+        if (connection) {
+            closeConnection(connection);
+        }
+    }
+}
+
+function executeCommand(connection, command, ...args) {
+    return connection[command](...args);
+}
+
+function closeConnection(connection) {
+    if (!connection.pool) {
+        return destroyConnection(connection);
+    } else {
+        return getPool({connectionName: connection.connectionName}).release(connection);
+    }
+}
+
+function destroyConnection(connection) {
+    connection.disconnect();
+    connection.active = false;
+    return Promise.resolve();
+}
+
+function checkConnection(connection) {
+    connection.ping().catch((err) => { connection.active = false; });
+}
+
+function scheduleKeepAliveRun(connection, interval) {
+    if (connection.pool) {
+        connection.scheduledKeepAlive = setTimeout(() => {
+            checkConnection(connection);
+            scheduleKeepAliveRun(connection, interval);
+        }, interval);
+    }
+}
+
+function descheduleKeepAliveRun(connection) {
+    if (connection.scheduledKeepAlive) {
+        clearTimeout(connection.scheduledKeepAlive);
+    }
+    connection.scheduledKeepAlive = null;
+}
+
+function getPool(config) {
+    let key = config.connectionName;
+    let pool = poolsByName[key];
+    if (pool) {
+        return pool;
+    }
+    else {
+        // Create pool using a factory object
+        const factory = {
+            create: async function() {
+                try {
+                    const connection = await createConnection(config);
+                    scheduleKeepAliveRun(connection, config.poolKeepAlive);
+                    return connection;
+                } catch (err) {
+                    return await new Promise(function (resolve, reject) {
+                        setTimeout(() => {
+                            reject(err);
+                        }, config.poolRetryDelay);
+                    });
+                }
+            },
+            destroy: async function(connection) {
+                await destroyConnection(connection);
+                descheduleKeepAliveRun(connection);
+                return true;
+            },
+            validate: function(connection) {
+                return Promise.resolve(connection.active);
+            }
+        };
+
+        const opts = {
+            max: config.poolMax,
+            min: config.poolMin,
+            testOnBorrow: true,
+            acquireTimeoutMillis: config.poolAcquireTimeout || 10000
+            //autostart: false
+        };
+
+        pool = genericPool.createPool(factory, opts);
+        //pool.start();
+        pool.connectionName = config.connectionName;
+        poolsByName[key] = pool;
+        return pool;
+    }
+}
+
+function error(code, data, innerError) {
+    let err = new Error();
+    err.code = code;
+    if (data)
+        err.data = data;
+    if (innerError)
+        err.innerError = innerError;
+    return err;
+}
+
+module.exports = {
+    createRedisClient: createRedisClient
+}

package/blz-regex/index.js

@@ -0,0 +1,25 @@
+module.exports = {
+    regexReplace: function (target, regex, newValue) {
+        if (target === null || target === undefined)
+            return null;
+        if (regex === null || regex === undefined)
+            return target;
+        if (newValue === null || newValue === undefined)
+            return target;
+        return target.replace(new RegExp(regex, 'g'), newValue);
+    },
+    regexSearch: function (target, regex) {
+        if (target === null || target === undefined)
+            return -1;
+        if (regex === null || regex === undefined)
+            return -1;
+        return target.search(new RegExp(regex, 'g'));
+    },
+    regexTest: function (target, regex) {
+        if (target === null || target === undefined)
+            return false;
+        if (regex === null || regex === undefined)
+            return false;
+        return new RegExp(regex, 'g').test(target);
+    }
+};

package/blz-security/.eslintrc.js

@@ -0,0 +1,15 @@
+module.exports = {
+  env: {
+    browser: true,
+    commonjs: true,
+    es2021: true
+  },
+  extends: [
+    'standard'
+  ],
+  parserOptions: {
+    ecmaVersion: 12
+  },
+  rules: {
+  }
+}