@azteam/redis-async 1.0.37

package/README.md

@@ -0,0 +1 @@
+# redis-async

package/package.json

@@ -0,0 +1,30 @@
+{
+    "name": "@azteam/redis-async",
+    "version": "1.0.37",
+    "description": "",
+    "main": "src/index.js",
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/toda93/redis-async.git"
+    },
+    "engines": {
+        "node": ">= 10.0.0",
+        "npm": "^6.0.0"
+    },
+    "keywords": [
+        "toda",
+        "nodejs",
+        "redis",
+        "redis async"
+    ],
+    "author": "toda <sp.azsolution.net@gmail.com>",
+    "license": "MIT",
+    "bugs": {
+        "url": "https://github.com/toda93/redis-async/issues"
+    },
+    "homepage": "https://github.com/toda93/redis-async#readme",
+    "dependencies": {
+        "@azteam/util": "1.0.3",
+        "redis": "~2.8.0"
+    }
+}

package/src/Provider.js

@@ -0,0 +1,17 @@
+import RedisAsync from './RedisAsync';
+
+class Provider {
+    constructor(configs) {
+        this.configs = configs;
+        this.connections = {};
+    }
+    getConnection(name) {
+        if (!this.connections[name]) {
+            this.connections[name] = new RedisAsync(this.configs[name]);
+        }
+        return this.connections[name];
+    }
+
+}
+
+export default Provider;

package/src/RedisAsync.js

@@ -0,0 +1,154 @@
+import redis from 'redis';
+import { promisify } from 'util';
+import { timeout } from '@azteam/util';
+
+
+class RedisAsync {
+    constructor(config) {
+        this.connected = false;
+        this.host = config.host;
+        this.port = config.port;
+        this.prefix = config.prefix;
+        this.connect();
+    }
+
+    async waitConnection(n = 10) {
+        let i = 0;
+        while (!this.connected) {
+            ++i;
+            if (i >= n) {
+                return false;
+            }
+            await timeout(1000);
+        }
+        return true;
+    }
+
+    parsePrefix(name) {
+        if (this.prefix) {
+            return `${this.prefix}:${name}`;
+        }
+        return name;
+    }
+
+    connect() {
+        this._alert('connecting', 'Redis connecting...');
+
+        this.client = redis.createClient({
+            host: this.host,
+            port: this.port,
+
+            retry_strategy: (options) => {
+                this.connected = false;
+                this._alert('Redis disconnected');
+                this.client.quit();
+            }
+        });
+        this.client.on('connect', () => {
+            this.connected = true;
+            this._alert('connect', 'Redis connected');
+        });
+
+        this.client.on('end', () => {
+            this._alert('end', 'Redis end');
+        });
+
+        this.client.on('error', (err) => {
+            this._alert('error', 'Redis Error' + err);
+        });
+    }
+
+    async get(key, defaultValue = null) {
+
+        const prefixKey = this.parsePrefix(key);
+
+        if (this.connected) {
+
+            console.log(`Redis GET ${prefixKey}`);
+
+            const getAsync = promisify(this.client.get).bind(this.client);
+            const data = await getAsync(prefixKey);
+            if (data) {
+                return JSON.parse(data);
+            }
+        } else {
+            this.connect();
+            return this.get(key);
+        }
+
+        return defaultValue;
+    }
+
+
+    async ttl(key) {
+        const prefixKey = this.parsePrefix(key);
+
+        const ttlAsync = promisify(this.client.ttl).bind(this.client);
+        return await ttlAsync(prefixKey);
+    }
+
+    async expire(key, time = 100000) {
+        const prefixKey = this.parsePrefix(key);
+
+        this.client.expire(prefixKey, time);
+    }
+
+    async set(key, data, time = 100000) {
+        const prefixKey = this.parsePrefix(key);
+
+        if (this.connected) {
+            console.log(`Redis SET ${prefixKey}`);
+            return await this.client.set(prefixKey, JSON.stringify(data), 'EX', time);
+        } else {
+            this.connect();
+            return this.set(key, data, time);
+        }
+    }
+
+    async scan(pattern, cursor = 0, count = 1000) {
+        const scanAsync = promisify(this.client.scan).bind(this.client);
+        return await scanAsync(cursor, 'MATCH', pattern, 'COUNT', count);
+    }
+
+    async remove(key, exact = true) {
+        const prefixKey = this.parsePrefix(key);
+
+        if (this.connected) {
+
+            if (exact) {
+                console.log(`Redis REMOVE ${prefixKey}`);
+
+                await this.client.del(prefixKey);
+            } else {
+                const regexKey = '*' + prefixKey + '*';
+
+                const getAsync = promisify(this.client.keys).bind(this.client);
+                const keys = await getAsync(regexKey);
+
+                if (keys.length > 0) {
+                    console.log(`Redis REMOVE keys`, keys);
+                    return await this.client.del(keys);
+                }
+            }
+
+        } else {
+            this.connect();
+            return this.remove(key, exact);
+        }
+    }
+
+
+    setAlertCallback(callback) {
+        this.alertCallback = callback;
+    }
+
+    _alert(status, msg) {
+        if (typeof this.alertCallback === 'function') {
+            this.alertCallback(status, msg);
+        } else {
+            console.error(status, msg);
+        }
+    }
+}
+
+export default RedisAsync;

package/src/index.js

@@ -0,0 +1,7 @@
+import Provider from './Provider';
+import RedisAsync from './RedisAsync';
+
+export {
+    RedisAsync,
+    Provider as RedisProvider,
+}