@blazedpath/commons 0.3.1 → 0.4.0

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: {
+  }
+}