@blazedpath/commons 0.2.1 → 0.3.1

package/blz-redis/index.js

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

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

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

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