koatty_store 1.5.4 → 1.5.6

package/dist/index.js

@@ -1,54 +1,1916 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Store = exports.CacheStore = exports.MemoryStore = void 0;
-const memory_1 = require("./store/memory");
-const redis_1 = require("./store/redis");
-var memory_2 = require("./store/memory");
-Object.defineProperty(exports, "MemoryStore", { enumerable: true, get: function () { return memory_2.MemoryStore; } });
-// export
-var store_1 = require("./store");
-Object.defineProperty(exports, "CacheStore", { enumerable: true, get: function () { return store_1.CacheStore; } });
-/**
- *
- *
- * @export
- * @class Store
- */
-class Store {
-    /**
-     *
-     *
-     * @static
-     * @returns
-     * @memberof ValidateUtil
-     */
-    static getInstance(options) {
-        if (this.instance) {
-            return this.instance;
-        }
-        options = {
-            ...{
-                type: 'memory',
-                host: '',
-                port: 0,
-                keyPrefix: 'Koatty',
-                timeout: 600,
-                poolSize: 10,
-                connectTimeout: 500,
-                db: 0
-            }, ...options
-        };
-        switch (options.type) {
-            case "redis":
-                this.instance = new redis_1.RedisStore(options);
-                break;
-            case "memory":
-            default:
-                this.instance = new memory_1.MemoryStore(options);
-                break;
-        }
-        return this.instance;
+/*!
+* @Author: richen
+* @Date: 2022-11-03 16:31:15
+* @License: BSD (3-Clause)
+* @Copyright (c) - <richenlin(at)gmail.com>
+* @HomePage: https://koatty.org/
+*/
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var lodash = require('lodash');
+var helper = require('koatty_lib');
+var events = require('events');
+var koatty_logger = require('koatty_logger');
+var IORedis = require('ioredis');
+var genericPool = require('generic-pool');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+function _interopNamespace(e) {
+    if (e && e.__esModule) return e;
+    var n = Object.create(null);
+    if (e) {
+        Object.keys(e).forEach(function (k) {
+            if (k !== 'default') {
+                var d = Object.getOwnPropertyDescriptor(e, k);
+                Object.defineProperty(n, k, d.get ? d : {
+                    enumerable: true,
+                    get: function () { return e[k]; }
+                });
+            }
+        });
     }
+    n["default"] = e;
+    return Object.freeze(n);
 }
+
+var helper__namespace = /*#__PURE__*/_interopNamespace(helper);
+var IORedis__default = /*#__PURE__*/_interopDefaultLegacy(IORedis);
+var genericPool__default = /*#__PURE__*/_interopDefaultLegacy(genericPool);
+
+/*
+ * @Description:
+ * @Usage:
+ * @Author: richen
+ * @Date: 2021-12-02 15:26:55
+ * @LastEditTime: 2021-12-02 15:33:22
+ */
+/**
+ *
+ *
+ * @export
+ * @class Store
+ */
+class CacheStore {
+    /**
+     * Creates an instance of CacheStore.
+     * @param {StoreOptions} options
+     * @memberof CacheStore
+     */
+    constructor(options) {
+        this.options = options;
+        this.pool = null;
+        this.client = null;
+    }
+    getConnection() {
+        throw new Error("Method not implemented.");
+    }
+    close() {
+        throw new Error("Method not implemented.");
+    }
+    release(conn) {
+        throw new Error("Method not implemented.");
+    }
+    defineCommand(name, scripts) {
+        throw new Error("Method not implemented.");
+    }
+    getCompare(name, value) {
+        throw new Error("Method not implemented.");
+    }
+    /**
+     * handler for native client
+     *
+     * @param {string} name
+     * @param {any[]} data
+     * @returns {*}
+     * @memberof RedisStore
+     */
+    async wrap(name, data) {
+        let conn;
+        try {
+            conn = await this.getConnection();
+            const res = await conn[name](...data);
+            return res;
+        }
+        catch (err) {
+            throw err;
+        }
+        finally {
+            this.release(conn);
+        }
+    }
+    /**
+     * 字符串获取
+     * @param name
+     */
+    get(name) {
+        return this.wrap('get', [`${this.options.keyPrefix}${name}`]);
+    }
+    /**
+     * 字符串写入
+     * @param name
+     * @param value
+     * @param timeout
+     * @returns {Promise}
+     */
+    set(name, value, timeout) {
+        if (typeof timeout !== 'number') {
+            timeout = this.options.timeout;
+        }
+        return this.wrap('set', [`${this.options.keyPrefix}${name}`, value, 'ex', timeout]);
+    }
+    /**
+     * 以秒为单位，返回给定 key 的剩余生存时间
+     * @param name
+     * @returns {*}
+     */
+    ttl(name) {
+        return this.wrap('ttl', [`${this.options.keyPrefix}${name}`]);
+    }
+    /**
+     * 设置key超时属性
+     * @param name
+     * @param timeout
+     */
+    expire(name, timeout) {
+        return this.wrap('expire', [`${this.options.keyPrefix}${name}`, timeout]);
+    }
+    /**
+     * 删除key
+     * @param name
+     */
+    rm(name) {
+        return this.wrap('del', [`${this.options.keyPrefix}${name}`]);
+    }
+    /**
+     *
+     *
+     * @param {*} name
+     * @returns
+     */
+    del(name) {
+        return this.wrap('del', [`${this.options.keyPrefix}${name}`]);
+    }
+    /**
+     * 判断key是否存在
+     * @param name
+     */
+    exists(name) {
+        return this.wrap('exists', [`${this.options.keyPrefix}${name}`]);
+    }
+    /**
+     * 自增
+     * @param name
+     */
+    incr(name) {
+        return this.wrap('incr', [`${this.options.keyPrefix}${name}`]);
+    }
+    /**
+     * 自减
+     * @param name
+     * @returns {*}
+     */
+    decr(name) {
+        return this.wrap('decr', [`${this.options.keyPrefix}${name}`]);
+    }
+    /**
+     * 将 key 所储存的值增加增量
+     * @param name
+     * @param incr
+     * @returns {*}
+     */
+    incrby(name, incr = 1) {
+        return this.wrap('incrby', [`${this.options.keyPrefix}${name}`, incr]);
+    }
+    /**
+     * 将 key 所储存的值减去减量
+     *
+     * @param {any} name
+     * @param {any} decr
+     */
+    decrby(name, decr = 1) {
+        return this.wrap('decrby', [`${this.options.keyPrefix}${name}`, decr]);
+    }
+    /**
+     * 哈希写入
+     * @param name
+     * @param key
+     * @param value
+     * @param timeout
+     */
+    hset(name, key, value, timeout) {
+        const setP = [this.wrap('hset', [`${this.options.keyPrefix}${name}`, key, value])];
+        if (typeof timeout !== 'number') {
+            timeout = this.options.timeout;
+        }
+        setP.push(this.set(`${name}:${key}_ex`, 1, timeout));
+        return Promise.all(setP);
+    }
+    /**
+     * 哈希获取
+     * @param name
+     * @param key
+     * @returns {*}
+     */
+    hget(name, key) {
+        const setP = [this.get(`${name}:${key}_ex`)];
+        setP.push(this.wrap('hget', [`${this.options.keyPrefix}${name}`, key]));
+        return Promise.all(setP).then(dataArr => {
+            if (dataArr[0] === null) {
+                this.hdel(name, key);
+                return null;
+            }
+            return dataArr[1] || null;
+        });
+    }
+    /**
+     * 查看哈希表 hashKey 中，给定域 key 是否存在
+     * @param name
+     * @param key
+     * @returns {*}
+     */
+    hexists(name, key) {
+        const setP = [this.get(`${name}:${key}_ex`)];
+        setP.push(this.wrap('hexists', [`${this.options.keyPrefix}${name}`, key]));
+        return Promise.all(setP).then(dataArr => {
+            if (dataArr[0] === null) {
+                this.hdel(name, key);
+                return 0;
+            }
+            return dataArr[1] || 0;
+        });
+    }
+    /**
+     * 哈希删除
+     * @param name
+     * @param key
+     * @returns {*}
+     */
+    hdel(name, key) {
+        const setP = [this.del(`${name}:${key}_ex`)];
+        setP.push(this.wrap('hdel', [`${this.options.keyPrefix}${name}`, key]));
+        return Promise.all(setP);
+    }
+    /**
+     * 返回哈希表 key 中域的数量
+     * @param name
+     * @returns {*}
+     */
+    hlen(name) {
+        return this.wrap('hlen', [`${this.options.keyPrefix}${name}`]);
+    }
+    /**
+     * 给哈希表指定key，增加increment
+     * @param name
+     * @param key
+     * @param incr
+     * @returns {*}
+     */
+    hincrby(name, key, incr = 1) {
+        return this.wrap('hincrby', [`${this.options.keyPrefix}${name}`, key, incr]);
+    }
+    /**
+     * 返回哈希表所有key-value
+     * @param name
+     * @returns {*}
+     */
+    hgetall(name) {
+        return this.wrap('hgetall', [`${this.options.keyPrefix}${name}`]);
+    }
+    /**
+     * 返回哈希表所有key
+     * @param name
+     * @returns {*}
+     */
+    hkeys(name) {
+        return this.wrap('hkeys', [`${this.options.keyPrefix}${name}`]);
+    }
+    /**
+     * 返回哈希表所有value
+     * @param name
+     * @returns {*}
+     */
+    hvals(name) {
+        return this.wrap('hvals', [`${this.options.keyPrefix}${name}`]);
+    }
+    /**
+     * 判断列表长度，若不存在则表示为空
+     * @param name
+     * @returns {*}
+     */
+    llen(name) {
+        return this.wrap('llen', [`${this.options.keyPrefix}${name}`]);
+    }
+    /**
+     * 将值插入列表表尾
+     * @param name
+     * @param value
+     * @returns {*}
+     */
+    rpush(name, value) {
+        return this.wrap('rpush', [`${this.options.keyPrefix}${name}`, value]);
+    }
+    /**
+     *
+     *
+     * @param {string} name
+     * @param {(string | number)} value
+     * @returns {*}
+     * @memberof RedisStore
+     */
+    lpush(name, value) {
+        return this.wrap('lpush', [`${this.options.keyPrefix}${name}`, value]);
+    }
+    /**
+     * 将列表表头取出，并去除
+     * @param name
+     * @returns {*}
+     */
+    lpop(name) {
+        return this.wrap('lpop', [`${this.options.keyPrefix}${name}`]);
+    }
+    /**
+     *
+     *
+     * @param {string} name
+     * @returns {*}
+     * @memberof RedisStore
+     */
+    rpop(name) {
+        return this.wrap('rpop', [`${this.options.keyPrefix}${name}`]);
+    }
+    /**
+     * 返回列表 key 中指定区间内的元素，区间以偏移量 start 和 stop 指定
+     * @param name
+     * @param start
+     * @param stop
+     * @returns {*}
+     */
+    lrange(name, start, stop) {
+        return this.wrap('lrange', [`${this.options.keyPrefix}${name}`, start, stop]);
+    }
+    /**
+     * 集合新增
+     * @param name
+     * @param value
+     * @param timeout
+     * @returns {*}
+     */
+    sadd(name, value, timeout) {
+        const setP = [this.wrap('sadd', [`${this.options.keyPrefix}${name}`, value])];
+        if (typeof timeout !== 'number') {
+            setP.push(this.wrap('expire', [`${this.options.keyPrefix}${name}`, timeout]));
+        }
+        return Promise.all(setP);
+    }
+    /**
+     * 返回集合的基数(集合中元素的数量)
+     * @param name
+     * @returns {*}
+     */
+    scard(name) {
+        return this.wrap('scard', [`${this.options.keyPrefix}${name}`]);
+    }
+    /**
+     * 判断 member 元素是否集合的成员
+     * @param name
+     * @param key
+     * @returns {*}
+     */
+    sismember(name, key) {
+        return this.wrap('sismember', [`${this.options.keyPrefix}${name}`, key]);
+    }
+    /**
+     * 返回集合中的所有成员
+     * @param name
+     * @returns {*}
+     */
+    smembers(name) {
+        return this.wrap('smembers', [`${this.options.keyPrefix}${name}`]);
+    }
+    /**
+     * 移除并返回集合中的一个随机元素
+     * @param name
+     * @returns {*}
+     */
+    spop(name) {
+        return this.wrap('spop', [`${this.options.keyPrefix}${name}`]);
+    }
+    /**
+     * 移除集合 key 中的一个 member 元素
+     * @param name
+     * @param key
+     * @returns {*}
+     */
+    srem(name, key) {
+        return this.wrap('srem', [`${this.options.keyPrefix}${name}`, key]);
+    }
+    /**
+     * 将 member 元素从 source 集合移动到 destination 集合
+     * @param source
+     * @param destination
+     * @param member
+     * @returns {*}
+     */
+    smove(source, destination, member) {
+        return this.wrap('smove', [`${this.options.keyPrefix}${source}`, `${this.options.keyPrefix}${destination}`, member]);
+    }
+}
+
+/*
+ * @Description:
+ * @Usage:
+ * @Author: richen
+ * @Date: 2021-12-02 11:03:20
+ * @LastEditTime: 2021-12-02 14:36:11
+ */
+/**
+ *
+ *
+ * @enum {number}
+ */
+var messages;
+(function (messages) {
+    messages["ok"] = "OK";
+    messages["queued"] = "QUEUED";
+    messages["pong"] = "PONG";
+    messages["noint"] = "ERR value is not an integer or out of range";
+    messages["nofloat"] = "ERR value is not an float or out of range";
+    messages["nokey"] = "ERR no such key";
+    messages["nomultiinmulti"] = "ERR MULTI calls can not be nested";
+    messages["nomultiexec"] = "ERR EXEC without MULTI";
+    messages["nomultidiscard"] = "ERR DISCARD without MULTI";
+    messages["busykey"] = "ERR target key name is busy";
+    messages["syntax"] = "ERR syntax error";
+    messages["unsupported"] = "MemoryCache does not support that operation";
+    messages["wrongTypeOp"] = "WRONGTYPE Operation against a key holding the wrong kind of value";
+    messages["wrongPayload"] = "DUMP payload version or checksum are wrong";
+    messages["wrongArgCount"] = "ERR wrong number of arguments for '%0' command";
+    messages["bitopnotWrongCount"] = "ERR BITOP NOT must be called with a single source key";
+    messages["indexOutOfRange"] = "ERR index out of range";
+    messages["invalidLexRange"] = "ERR min or max not valid string range item";
+    messages["invalidDBIndex"] = "ERR invalid DB index";
+    messages["invalidDBIndexNX"] = "ERR invalid DB index, '%0' does not exist";
+    messages["mutuallyExclusiveNXXX"] = "ERR XX and NX options at the same time are not compatible";
+})(messages || (messages = {}));
+class MemoryCache extends events.EventEmitter {
+    /**
+     * Creates an instance of MemoryCache.
+     * @param {*} options
+     * @memberof MemoryCache
+     */
+    constructor(options) {
+        super();
+        this.databases = Object.create({});
+        this.options = { ...{ database: "0" }, ...options };
+        this.currentDBIndex = 0;
+        this.connected = false;
+        this.lastSave = Date.now();
+        this.multiMode = false;
+    }
+    /**
+     *
+     *
+     * @returns {*}
+     * @memberof MemoryCache
+     */
+    createClient() {
+        this.databases[this.options.database] = Object.create({});
+        this.cache = this.databases[this.options.database];
+        this.connected = true;
+        // exit multi mode if we are in it
+        this.discard(null, true);
+        this.emit('connect');
+        this.emit('ready');
+        return this;
+    }
+    /**
+     *
+     *
+     * @returns {*}
+     * @memberof MemoryCache
+     */
+    quit() {
+        this.connected = false;
+        // exit multi mode if we are in it
+        this.discard(null, true);
+        this.emit('end');
+        return this;
+    }
+    /**
+     *
+     *
+     * @returns {*}
+     * @memberof MemoryCache
+     */
+    end() {
+        return this.quit();
+    }
+    /**
+     *
+     *
+     * @param {string} message
+     * @param {Function} [callback]
+     * @returns {*}
+     * @memberof MemoryCache
+     */
+    echo(message, callback) {
+        return this._handleCallback(callback, message);
+    }
+    /**
+     *
+     *
+     * @param {string} message
+     * @param {Function} [callback]
+     * @returns {*}
+     * @memberof MemoryCache
+     */
+    ping(message, callback) {
+        message = message || messages.pong;
+        return this._handleCallback(callback, message);
+    }
+    /**
+     *
+     *
+     * @param {string} password
+     * @param {Function} [callback]
+     * @returns {*}
+     * @memberof MemoryCache
+     */
+    auth(password, callback) {
+        return this._handleCallback(callback, messages.ok);
+    }
+    /**
+     *
+     *
+     * @param {number} dbIndex
+     * @param {Function} [callback]
+     * @returns {*}
+     * @memberof MemoryCache
+     */
+    select(dbIndex, callback) {
+        if (!helper__namespace.isNumber(dbIndex)) {
+            return this._handleCallback(callback, null, messages.invalidDBIndex);
+        }
+        if (!this.databases.hasOwnProperty(dbIndex)) {
+            this.databases[dbIndex] = Object.create({});
+        }
+        this.multiMode = false;
+        this.currentDBIndex = dbIndex;
+        this.cache = this.databases[dbIndex];
+        return this._handleCallback(callback, messages.ok);
+    }
+    // ---------------------------------------
+    // Keys
+    // ---------------------------------------
+    get(key, callback) {
+        let retVal = null;
+        if (this._hasKey(key)) {
+            this._testType(key, 'string', true, callback);
+            retVal = this._getKey(key);
+        }
+        return this._handleCallback(callback, retVal);
+    }
+    /**
+     * set(key, value, ttl, pttl, notexist, onlyexist, callback)
+     *
+     * @param {string} key
+     * @param {(string | number)} value
+     * @param {...any[]} params
+     * @returns {*}
+     * @memberof MemoryCache
+     */
+    set(key, value, ...params) {
+        const retVal = null;
+        params = lodash.flatten(params);
+        const callback = this._retrieveCallback(params);
+        let ttl, pttl, notexist, onlyexist;
+        // parse parameters
+        while (params.length > 0) {
+            const param = params.shift();
+            switch (param.toString().toLowerCase()) {
+                case 'nx':
+                    notexist = true;
+                    break;
+                case 'xx':
+                    onlyexist = true;
+                    break;
+                case 'ex':
+                    if (params.length === 0) {
+                        return this._handleCallback(callback, null, messages.syntax);
+                    }
+                    ttl = parseInt(params.shift());
+                    if (isNaN(ttl)) {
+                        return this._handleCallback(callback, null, messages.noint);
+                    }
+                    break;
+                case 'px':
+                    if (params.length === 0) {
+                        return this._handleCallback(callback, null, messages.syntax);
+                    }
+                    pttl = parseInt(params.shift());
+                    if (isNaN(pttl)) {
+                        return this._handleCallback(callback, null, messages.noint);
+                    }
+                    break;
+                default:
+                    return this._handleCallback(callback, null, messages.syntax);
+            }
+        }
+        if (!lodash.isNil(ttl) && !lodash.isNil(pttl)) {
+            return this._handleCallback(callback, null, messages.syntax);
+        }
+        if (notexist && onlyexist) {
+            return this._handleCallback(callback, null, messages.syntax);
+        }
+        pttl = pttl || ttl * 1000 || null;
+        if (!lodash.isNil(pttl)) {
+            pttl = Date.now() + pttl;
+        }
+        if (this._hasKey(key)) {
+            this._testType(key, 'string', true, callback);
+            if (notexist) {
+                return this._handleCallback(callback, retVal);
+            }
+        }
+        else if (onlyexist) {
+            return this._handleCallback(callback, retVal);
+        }
+        this.cache[key] = this._makeKey(value.toString(), 'string', pttl);
+        return this._handleCallback(callback, messages.ok);
+    }
+    /**
+     *
+     *
+     * @param {string} key
+     * @param {Function} [callback]
+     * @returns {*}
+     * @memberof MemoryCache
+     */
+    ttl(key, callback) {
+        let retVal = this.pttl(key);
+        if (retVal >= 0 || retVal <= -3) {
+            retVal = Math.floor(retVal / 1000);
+        }
+        return this._handleCallback(callback, retVal);
+    }
+    /**
+     *
+     *
+     * @param {string} key
+     * @param {number} seconds
+     * @param {Function} [callback]
+     * @returns {*}
+     * @memberof MemoryCache
+     */
+    expire(key, seconds, callback) {
+        let retVal = 0;
+        if (this._hasKey(key)) {
+            this.cache[key].timeout = Date.now() + seconds * 1000;
+            retVal = 1;
+        }
+        return this._handleCallback(callback, retVal);
+    }
+    /**
+     *
+     *
+     * @param {...any[]} keys
+     * @returns {*}
+     * @memberof MemoryCache
+     */
+    del(...keys) {
+        let retVal = 0;
+        const callback = this._retrieveCallback(keys);
+        // Flatten the array in case an array was passed
+        keys = lodash.flatten(keys);
+        for (let itr = 0; itr < keys.length; itr++) {
+            const key = keys[itr];
+            if (this._hasKey(key)) {
+                delete this.cache[key];
+                retVal++;
+            }
+        }
+        return this._handleCallback(callback, retVal);
+    }
+    /**
+     *
+     *
+     * @param {...any[]} keys
+     * @returns {*}
+     * @memberof MemoryCache
+     */
+    exists(...keys) {
+        let retVal = 0;
+        const callback = this._retrieveCallback(keys);
+        for (let itr = 0; itr < keys.length; itr++) {
+            const key = keys[itr];
+            if (this._hasKey(key)) {
+                retVal++;
+            }
+        }
+        return this._handleCallback(callback, retVal);
+    }
+    /**
+     *
+     *
+     * @param {string} key
+     * @param {Function} [callback]
+     * @returns {*}
+     * @memberof MemoryCache
+     */
+    incr(key, callback) {
+        let retVal = null;
+        try {
+            retVal = this._addToKey(key, 1);
+        }
+        catch (err) {
+            return this._handleCallback(callback, null, err);
+        }
+        return this._handleCallback(callback, retVal);
+    }
+    /**
+     *
+     *
+     * @param {string} key
+     * @param {number} amount
+     * @param {Function} [callback]
+     * @returns {*}
+     * @memberof MemoryCache
+     */
+    incrby(key, amount, callback) {
+        let retVal = null;
+        try {
+            retVal = this._addToKey(key, amount);
+        }
+        catch (err) {
+            return this._handleCallback(callback, null, err);
+        }
+        return this._handleCallback(callback, retVal);
+    }
+    /**
+     *
+     *
+     * @param {string} key
+     * @param {Function} [callback]
+     * @returns {*}
+     * @memberof MemoryCache
+     */
+    decr(key, callback) {
+        let retVal = null;
+        try {
+            retVal = this._addToKey(key, -1);
+        }
+        catch (err) {
+            return this._handleCallback(callback, null, err);
+        }
+        return this._handleCallback(callback, retVal);
+    }
+    /**
+     *
+     *
+     * @param {string} key
+     * @param {number} amount
+     * @param {Function} [callback]
+     * @returns {*}
+     * @memberof MemoryCache
+     */
+    decrby(key, amount, callback) {
+        let retVal = null;
+        try {
+            retVal = this._addToKey(key, -amount);
+        }
+        catch (err) {
+            return this._handleCallback(callback, null, err);
+        }
+        return this._handleCallback(callback, retVal);
+    }
+    // ---------------------------------------
+    // ## Hash ##
+    // ---------------------------------------
+    hset(key, field, value, callback) {
+        let retVal = 0;
+        if (this._hasKey(key)) {
+            this._testType(key, 'hash', true, callback);
+        }
+        else {
+            this.cache[key] = this._makeKey({}, 'hash');
+        }
+        if (!this._hasField(key, field)) {
+            retVal = 1;
+        }
+        this._setField(key, field, value.toString());
+        this.persist(key);
+        return this._handleCallback(callback, retVal);
+    }
+    /**
+     *
+     *
+     * @param {string} key
+     * @param {string} field
+     * @param {Function} [callback]
+     * @returns {*}
+     * @memberof MemoryCache
+     */
+    hget(key, field, callback) {
+        let retVal = null;
+        if (this._hasKey(key)) {
+            this._testType(key, 'hash', true, callback);
+            if (this._hasField(key, field)) {
+                retVal = this._getKey(key)[field];
+            }
+        }
+        return this._handleCallback(callback, retVal);
+    }
+    /**
+     *
+     *
+     * @param {string} key
+     * @param {string} field
+     * @param {Function} [callback]
+     * @returns {*}
+     * @memberof MemoryCache
+     */
+    hexists(key, field, callback) {
+        let retVal = 0;
+        if (this._hasKey(key)) {
+            this._testType(key, 'hash', true, callback);
+            if (this._hasField(key, field)) {
+                retVal = 1;
+            }
+        }
+        return this._handleCallback(callback, retVal);
+    }
+    /**
+     *
+     *
+     * @param {string} key
+     * @param {...any[]} fields
+     * @returns {*}
+     * @memberof MemoryCache
+     */
+    hdel(key, ...fields) {
+        let retVal = 0;
+        const callback = this._retrieveCallback(fields);
+        if (this._hasKey(key)) {
+            this._testType(key, 'hash', true, callback);
+            for (let itr = 0; itr < fields.length; itr++) {
+                const field = fields[itr];
+                if (this._hasField(key, field)) {
+                    delete this.cache[key].value[field];
+                    retVal++;
+                }
+            }
+        }
+        return this._handleCallback(callback, retVal);
+    }
+    /**
+     *
+     *
+     * @param {string} key
+     * @param {Function} [callback]
+     * @returns {*}
+     * @memberof MemoryCache
+     */
+    hlen(key, callback) {
+        const retVal = this.hkeys(key).length;
+        return this._handleCallback(callback, retVal);
+    }
+    /**
+     *
+     *
+     * @param {string} key
+     * @param {string} field
+     * @param {*} value
+     * @param {Function} [callback]
+     * @returns {*}
+     * @memberof MemoryCache
+     */
+    hincrby(key, field, value, callback) {
+        let retVal;
+        try {
+            retVal = this._addToField(key, field, value, false);
+        }
+        catch (err) {
+            return this._handleCallback(callback, null, err);
+        }
+        return this._handleCallback(callback, retVal);
+    }
+    /**
+     *
+     *
+     * @param {string} key
+     * @param {Function} [callback]
+     * @returns {*}
+     * @memberof MemoryCache
+     */
+    hgetall(key, callback) {
+        let retVals = {};
+        if (this._hasKey(key)) {
+            this._testType(key, 'hash', true, callback);
+            retVals = this._getKey(key);
+        }
+        return this._handleCallback(callback, retVals);
+    }
+    /**
+    *
+    *
+    * @param {string} key
+    * @param {Function} [callback]
+    * @returns {*}
+    * @memberof MemoryCache
+    */
+    hkeys(key, callback) {
+        let retVals = [];
+        if (this._hasKey(key)) {
+            this._testType(key, 'hash', true, callback);
+            retVals = Object.keys(this._getKey(key));
+        }
+        return this._handleCallback(callback, retVals);
+    }
+    /**
+     *
+     *
+     * @param {string} key
+     * @param {Function} [callback]
+     * @returns {*}
+     * @memberof MemoryCache
+     */
+    hvals(key, callback) {
+        let retVals = [];
+        if (this._hasKey(key)) {
+            this._testType(key, 'hash', true, callback);
+            retVals = Object.values(this._getKey(key));
+        }
+        return this._handleCallback(callback, retVals);
+    }
+    // ---------------------------------------
+    // Lists (Array / Queue / Stack)
+    // ---------------------------------------
+    /**
+     *
+     *
+     * @param {string} key
+     * @param {Function} [callback]
+     * @returns {*}
+     * @memberof MemoryCache
+     */
+    llen(key, callback) {
+        let retVal = 0;
+        if (this._hasKey(key)) {
+            this._testType(key, 'list', true, callback);
+            retVal = this._getKey(key).length || 0;
+        }
+        return this._handleCallback(callback, retVal);
+    }
+    /**
+     *
+     *
+     * @param {string} key
+     * @param {(string | number)} value
+     * @param {Function} [callback]
+     * @returns {*}
+     * @memberof MemoryCache
+     */
+    rpush(key, value, callback) {
+        let retVal = 0;
+        if (this._hasKey(key)) {
+            this._testType(key, 'list', true, callback);
+        }
+        else {
+            this.cache[key] = this._makeKey([], 'list');
+        }
+        const val = this._getKey(key);
+        val.push(value);
+        this._setKey(key, val);
+        retVal = val.length;
+        return this._handleCallback(callback, retVal);
+    }
+    /**
+     *
+     *
+     * @param {string} key
+     * @param {(string | number)} value
+     * @param {Function} [callback]
+     * @returns {*}
+     * @memberof MemoryCache
+     */
+    lpush(key, value, callback) {
+        let retVal = 0;
+        if (this._hasKey(key)) {
+            this._testType(key, 'list', true, callback);
+        }
+        else {
+            this.cache[key] = this._makeKey([], 'list');
+        }
+        const val = this._getKey(key);
+        val.splice(0, 0, value);
+        this._setKey(key, val);
+        retVal = val.length;
+        return this._handleCallback(callback, retVal);
+    }
+    /**
+     *
+     *
+     * @param {string} key
+     * @param {Function} [callback]
+     * @returns {*}
+     * @memberof MemoryCache
+     */
+    lpop(key, callback) {
+        let retVal = null;
+        if (this._hasKey(key)) {
+            this._testType(key, 'list', true, callback);
+            const val = this._getKey(key);
+            retVal = val.shift();
+            this._setKey(key, val);
+        }
+        return this._handleCallback(callback, retVal);
+    }
+    /**
+     *
+     *
+     * @param {string} key
+     * @param {Function} [callback]
+     * @returns {*}
+     * @memberof MemoryCache
+     */
+    rpop(key, callback) {
+        let retVal = null;
+        if (this._hasKey(key)) {
+            this._testType(key, 'list', true, callback);
+            const val = this._getKey(key);
+            retVal = val.pop();
+            this._setKey(key, val);
+        }
+        return this._handleCallback(callback, retVal);
+    }
+    /**
+     *
+     *
+     * @param {string} key
+     * @param {number} start
+     * @param {number} stop
+     * @param {Function} [callback]
+     * @returns {*}
+     * @memberof MemoryCache
+     */
+    lrange(key, start, stop, callback) {
+        const retVal = [];
+        if (this._hasKey(key)) {
+            this._testType(key, 'list', true, callback);
+            const val = this._getKey(key);
+            const length = val.length;
+            if (stop < 0) {
+                stop = length + stop;
+            }
+            if (start < 0) {
+                start = length + start;
+            }
+            if (start < 0) {
+                start = 0;
+            }
+            if (stop >= length) {
+                stop = length - 1;
+            }
+            if (stop >= 0 && stop >= start) {
+                const size = stop - start + 1;
+                for (let itr = start; itr < size; itr++) {
+                    retVal.push(val[itr]);
+                }
+            }
+        }
+        return this._handleCallback(callback, retVal);
+    }
+    // ---------------------------------------
+    // ## Sets (Unique Lists)##
+    // ---------------------------------------
+    /**
+     *
+     *
+     * @param {string} key
+     * @param {...any[]} members
+     * @returns {*}
+     * @memberof MemoryCache
+     */
+    sadd(key, ...members) {
+        let retVal = 0;
+        const callback = this._retrieveCallback(members);
+        if (this._hasKey(key)) {
+            this._testType(key, 'set', true, callback);
+        }
+        else {
+            this.cache[key] = this._makeKey([], 'set');
+        }
+        const val = this._getKey(key);
+        const length = val.length;
+        const nval = lodash.union(val, members);
+        const newlength = nval.length;
+        retVal = newlength - length;
+        this._setKey(key, nval);
+        return this._handleCallback(callback, retVal);
+    }
+    /**
+     *
+     *
+     * @param {string} key
+     * @param {Function} [callback]
+     * @returns {*}
+     * @memberof MemoryCache
+     */
+    scard(key, callback) {
+        let retVal = 0;
+        if (this._hasKey(key)) {
+            this._testType(key, 'set', true, callback);
+            retVal = this._getKey(key).length;
+        }
+        return this._handleCallback(callback, retVal);
+    }
+    /**
+     *
+     *
+     * @param {string} key
+     * @param {string} member
+     * @param {Function} [callback]
+     * @returns {*}
+     * @memberof MemoryCache
+     */
+    sismember(key, member, callback) {
+        let retVal = 0;
+        if (this._hasKey(key)) {
+            this._testType(key, 'set', true, callback);
+            const val = this._getKey(key);
+            if (val.includes(member)) {
+                retVal = 1;
+            }
+        }
+        return this._handleCallback(callback, retVal);
+    }
+    /**
+     *
+     *
+     * @param {string} key
+     * @param {Function} [callback]
+     * @returns {*}
+     * @memberof MemoryCache
+     */
+    smembers(key, callback) {
+        let retVal = [];
+        if (this._hasKey(key)) {
+            this._testType(key, 'set', true, callback);
+            retVal = this._getKey(key);
+        }
+        return this._handleCallback(callback, retVal);
+    }
+    /**
+     *
+     *
+     * @param {string} key
+     * @param {number} [count]
+     * @param {Function} [callback]
+     * @returns {*}
+     * @memberof MemoryCache
+     */
+    spop(key, count, callback) {
+        let retVal = null;
+        count = count || 1;
+        if (isNaN(count)) {
+            return this._handleCallback(callback, null, messages.noint);
+        }
+        if (this._hasKey(key)) {
+            retVal = [];
+            this._testType(key, 'set', true, callback);
+            const val = this._getKey(key);
+            const length = val.length;
+            count = count > length ? length : count;
+            for (let itr = 0; itr < count; itr++) {
+                retVal.push(val.pop());
+            }
+        }
+        return this._handleCallback(callback, retVal);
+    }
+    /**
+     *
+     *
+     * @param {string} key
+     * @param {...any[]} members
+     * @returns {*}
+     * @memberof MemoryCache
+     */
+    srem(key, ...members) {
+        let retVal = 0;
+        const callback = this._retrieveCallback(members);
+        if (this._hasKey(key)) {
+            this._testType(key, 'set', true, callback);
+            const val = this._getKey(key);
+            for (const index in members) {
+                if (members.hasOwnProperty(index)) {
+                    const member = members[index];
+                    const idx = val.indexOf(member);
+                    if (idx !== -1) {
+                        val.splice(idx, 1);
+                        retVal++;
+                    }
+                }
+            }
+            this._setKey(key, val);
+        }
+        return this._handleCallback(callback, retVal);
+    }
+    /**
+     *
+     *
+     * @param {string} sourcekey
+     * @param {string} destkey
+     * @param {string} member
+     * @param {Function} [callback]
+     * @returns {*}
+     * @memberof MemoryCache
+     */
+    smove(sourcekey, destkey, member, callback) {
+        let retVal = 0;
+        if (this._hasKey(sourcekey)) {
+            this._testType(sourcekey, 'set', true, callback);
+            const val = this._getKey(sourcekey);
+            const idx = val.indexOf(member);
+            if (idx !== -1) {
+                this.sadd(destkey, member);
+                val.splice(idx, 1);
+                retVal = 1;
+            }
+        }
+        return this._handleCallback(callback, retVal);
+    }
+    // ---------------------------------------
+    // ## Transactions (Atomic) ##
+    // ---------------------------------------
+    // TODO: Transaction Queues watch and unwatch
+    // https://redis.io/topics/transactions
+    // This can be accomplished by temporarily swapping this.cache to a temporary copy of the current statement
+    // holding and then using __.merge on actual this.cache with the temp storage.
+    discard(callback, silent) {
+        // Clear the queue mode, drain the queue, empty the watch list
+        if (this.multiMode) {
+            this.cache = this.databases[this.currentDBIndex];
+            this.tempCache = {};
+            this.multiMode = false;
+            this.responseMessages = [];
+        }
+        else if (!silent) {
+            return this._handleCallback(callback, null, messages.nomultidiscard);
+        }
+        return this._handleCallback(callback, messages.ok);
+    }
+    // ---------------------------------------
+    // ## Internal - Key ##
+    // ---------------------------------------
+    /**
+     *
+     *
+     * @param {string} key
+     * @param {Function} [callback]
+     * @returns {*}
+     * @memberof MemoryCache
+     */
+    pttl(key, callback) {
+        let retVal = -2;
+        if (this._hasKey(key)) {
+            if (!lodash.isNil(this.cache[key].timeout)) {
+                retVal = this.cache[key].timeout - Date.now();
+                // Prevent unexpected errors if the actual ttl just happens to be -2 or -1
+                if (retVal < 0 && retVal > -3) {
+                    retVal = -3;
+                }
+            }
+            else {
+                retVal = -1;
+            }
+        }
+        return this._handleCallback(callback, retVal);
+    }
+    /**
+     *
+     *
+     * @private
+     * @param {string} key
+     * @param {Function} [callback]
+     * @returns {*}
+     * @memberof MemoryCache
+     */
+    persist(key, callback) {
+        let retVal = 0;
+        if (this._hasKey(key)) {
+            if (!lodash.isNil(this._key(key).timeout)) {
+                this._key(key).timeout = null;
+                retVal = 1;
+            }
+        }
+        return this._handleCallback(callback, retVal);
+    }
+    /**
+     *
+     *
+     * @private
+     * @param {string} key
+     * @returns {*}  {boolean}
+     * @memberof MemoryCache
+     */
+    _hasKey(key) {
+        return this.cache.hasOwnProperty(key);
+    }
+    /**
+     *
+     *
+     * @private
+     * @param {*} value
+     * @param {string} type
+     * @param {number} timeout
+     * @returns {*}
+     * @memberof MemoryCache
+     */
+    _makeKey(value, type, timeout) {
+        return { value: value, type: type, timeout: timeout || null, lastAccess: Date.now() };
+    }
+    /**
+     *
+     *
+     * @private
+     * @param {string} key
+     * @returns {*}
+     * @memberof MemoryCache
+     */
+    _key(key) {
+        this.cache[key].lastAccess = Date.now();
+        return this.cache[key];
+    }
+    /**
+     *
+     *
+     * @private
+     * @param {string} key
+     * @param {number} amount
+     * @param {Function} [callback]
+     * @returns {*}
+     * @memberof MemoryCache
+     */
+    _addToKey(key, amount, callback) {
+        let keyValue = 0;
+        if (isNaN(amount) || lodash.isNil(amount)) {
+            return this._handleCallback(callback, null, messages.noint);
+        }
+        if (this._hasKey(key)) {
+            this._testType(key, 'string', true, callback);
+            keyValue = parseInt(this._getKey(key));
+            if (isNaN(keyValue) || lodash.isNil(keyValue)) {
+                return this._handleCallback(callback, null, messages.noint);
+            }
+        }
+        else {
+            this.cache[key] = this._makeKey('0', 'string');
+        }
+        const val = keyValue + amount;
+        this._setKey(key, val.toString());
+        return val;
+    }
+    /**
+     *
+     *
+     * @private
+     * @param {string} key
+     * @param {string} type
+     * @param {boolean} [throwError]
+     * @param {Function} [callback]
+     * @returns {*}
+     * @memberof MemoryCache
+     */
+    _testType(key, type, throwError, callback) {
+        throwError = !!throwError;
+        const keyType = this._key(key).type;
+        if (keyType !== type) {
+            if (throwError) {
+                return this._handleCallback(callback, null, messages.wrongTypeOp);
+            }
+            return false;
+        }
+        return true;
+    }
+    /**
+     *
+     *
+     * @private
+     * @param {string} key
+     * @returns {*}
+     * @memberof MemoryCache
+     */
+    _getKey(key) {
+        const _key = this._key(key) || {};
+        if (_key.timeout && _key.timeout <= Date.now()) {
+            this.del(key);
+            return null;
+        }
+        return _key.value;
+    }
+    /**
+     *
+     *
+     * @private
+     * @param {string} key
+     * @param {(number | string)} value
+     * @memberof MemoryCache
+     */
+    _setKey(key, value) {
+        this.cache[key].value = value;
+        this.cache[key].lastAccess = Date.now();
+    }
+    /**
+     *
+     *
+     * @private
+     * @param {string} key
+     * @param {string} field
+     * @param {number} [amount]
+     * @param {boolean} [useFloat]
+     * @param {Function} [callback]
+     * @returns {*}
+     * @memberof MemoryCache
+     */
+    _addToField(key, field, amount, useFloat, callback) {
+        useFloat = useFloat || false;
+        let fieldValue = useFloat ? 0.0 : 0;
+        let value = 0;
+        if (isNaN(amount) || lodash.isNil(amount)) {
+            return this._handleCallback(callback, null, useFloat ? messages.nofloat : messages.noint);
+        }
+        if (this._hasKey(key)) {
+            this._testType(key, 'hash', true, callback);
+            if (this._hasField(key, field)) {
+                value = this._getField(key, field);
+            }
+        }
+        else {
+            this.cache[key] = this._makeKey({}, 'hash');
+        }
+        fieldValue = useFloat ? parseFloat(`${value}`) : parseInt(`${value}`);
+        amount = useFloat ? parseFloat(`${amount}`) : parseInt(`${amount}`);
+        if (isNaN(fieldValue) || lodash.isNil(fieldValue)) {
+            return this._handleCallback(callback, null, useFloat ? messages.nofloat : messages.noint);
+        }
+        fieldValue += amount;
+        this._setField(key, field, fieldValue.toString());
+        return fieldValue;
+    }
+    /**
+     *
+     *
+     * @private
+     * @param {string} key
+     * @param {string} field
+     * @returns {*}
+     * @memberof MemoryCache
+     */
+    _getField(key, field) {
+        return this._getKey(key)[field];
+    }
+    /**
+     *
+     *
+     * @private
+     * @param {string} key
+     * @param {string} field
+     * @returns {*}  {boolean}
+     * @memberof MemoryCache
+     */
+    _hasField(key, field) {
+        let retVal = false;
+        if (key && field) {
+            const ky = this._getKey(key);
+            if (ky) {
+                retVal = ky.hasOwnProperty(field);
+            }
+        }
+        return retVal;
+    }
+    /**
+     *
+     *
+     * @param {string} key
+     * @param {string} field
+     * @param {*} value
+     * @memberof MemoryCache
+     */
+    _setField(key, field, value) {
+        this._getKey(key)[field] = value;
+    }
+    /**
+     *
+     *
+     * @private
+     * @param {Function} [callback]
+     * @param {(any)} [message]
+     * @param {*} [error]
+     * @param {boolean} [nolog]
+     * @returns {*}
+     * @memberof MemoryCache
+     */
+    _handleCallback(callback, message, error, nolog) {
+        let err = error;
+        let msg = message;
+        nolog = lodash.isNil(nolog) ? true : nolog;
+        if (nolog) {
+            err = this._logReturn(error);
+            msg = this._logReturn(message);
+        }
+        if (typeof callback === 'function') {
+            callback(err, msg);
+            return;
+        }
+        if (err) {
+            throw new Error(err);
+        }
+        return msg;
+    }
+    _logReturn(message) {
+        if (!lodash.isUndefined(message)) {
+            if (this.multiMode) {
+                if (!lodash.isNil(this.responseMessages)) {
+                    this.responseMessages.push(message);
+                    if (message === messages.ok) {
+                        message = messages.queued;
+                    }
+                }
+            }
+            return message;
+        }
+        return;
+    }
+    /**
+     *
+     *
+     * @private
+     * @param {any[]} [params]
+     * @returns {*}
+     * @memberof MemoryCache
+     */
+    _retrieveCallback(params) {
+        if (Array.isArray(params) && params.length > 0 && typeof params[params.length - 1] === 'function') {
+            return params.pop();
+        }
+        return;
+    }
+}
+
+// const MemoryCache = require('@outofsync/memory-cache');
+/*
+ * @Description:
+ * @Usage:
+ * @Author: richen
+ * @Date: 2021-06-29 19:07:57
+ * @LastEditTime: 2021-12-02 15:30:12
+ */
+class MemoryStore extends CacheStore {
+    /**
+     * Creates an instance of MemoryStore.
+     * @param {StoreOptions} options
+     * @memberof MemoryStore
+     */
+    constructor(options) {
+        super(options);
+        this.options = options;
+        this.client = null;
+    }
+    /**
+     * getConnection
+     *
+     * @returns {*}
+     * @memberof MemoryStore
+     */
+    getConnection() {
+        if (!this.pool) {
+            this.pool = new MemoryCache({
+                database: this.options.db
+            });
+        }
+        if (!this.client) {
+            this.client = this.pool.createClient();
+            this.client.status = "ready";
+        }
+        return this.client;
+    }
+    /**
+     * close
+     *
+     * @returns {*}  {Promise<void>}
+     * @memberof MemoryStore
+     */
+    async close() {
+        this.client.end();
+        this.client = null;
+    }
+    /**
+     * release
+     *
+     * @param {*} conn
+     * @returns {*}  {Promise<void>}
+     * @memberof MemoryStore
+     */
+    async release(conn) {
+        return;
+    }
+    /**
+     * defineCommand
+     *
+     * @param {string} name
+     * @param {*} scripts
+     * @memberof MemoryStore
+     */
+    async defineCommand(name, scripts) {
+        throw new Error(messages.unsupported);
+    }
+    /**
+     * get and compare value
+     *
+     * @param {string} name
+     * @param {(string | number)} value
+     * @returns {*}  {Promise<any>}
+     * @memberof MemoryStore
+     */
+    async getCompare(name, value) {
+        const client = this.getConnection();
+        const val = client.get(`${this.options.keyPrefix}${name}`);
+        if (!val) {
+            return 0;
+        }
+        else if (val == value) {
+            return client.del(`${this.options.keyPrefix}${name}`);
+        }
+        else {
+            return -1;
+        }
+    }
+}
+
+/*
+ * @Author: richen
+ * @Date: 2020-11-30 15:56:08
+ * @LastEditors: Please set LastEditors
+ * @LastEditTime: 2021-12-02 15:30:11
+ * @License: BSD (3-Clause)
+ * @Copyright (c) - <richenlin(at)gmail.com>
+ */
+/**
+ *
+ *
+ * @export
+ * @class RedisStore
+ */
+class RedisStore extends CacheStore {
+    /**
+     * Creates an instance of RedisStore.
+     * @param {StoreOptions} options
+     * @memberof RedisStore
+     */
+    constructor(options) {
+        super(options);
+        this.options = this.parseOpt(options);
+        this.pool = null;
+        this.client = null;
+    }
+    // parseOpt
+    parseOpt(options) {
+        const opt = {
+            host: options.host || '127.0.0.1',
+            port: options.port || 3306,
+            username: options.username || "",
+            password: options.password || "",
+            db: options.db || 0,
+            timeout: options.timeout,
+            keyPrefix: options.keyPrefix || '',
+            poolSize: options.poolSize || 10,
+            connectTimeout: options.connectTimeout || 500,
+        };
+        if (helper__namespace.isArray(options.host)) {
+            const hosts = [];
+            for (let i = 0; i < options.host.length; i++) {
+                const h = options.host[i];
+                if (!helper__namespace.isEmpty(options.host[i])) {
+                    let p;
+                    if (helper__namespace.isArray(options.port)) {
+                        p = options.port[i];
+                    }
+                    else {
+                        p = options.port || 6379;
+                    }
+                    hosts.push({
+                        host: h,
+                        port: helper__namespace.toNumber(p),
+                    });
+                }
+            }
+            // sentinel
+            if (!helper__namespace.isEmpty(options.name)) {
+                opt.host = "";
+                opt.port = null;
+                opt.sentinels = [...hosts];
+                opt.sentinelUsername = options.username;
+                opt.sentinelPassword = options.password;
+            }
+            else {
+                // cluster
+                opt.host = "";
+                opt.port = null;
+                opt.clusters = [...hosts];
+            }
+        }
+        return opt;
+    }
+    /**
+     * create connection by native
+     *
+     * @param {number} [connNum=0]
+     * @returns {*}  {Promise<IORedis.Redis | IORedis.Cluster>}
+     * @memberof RedisStore
+     */
+    async connect(connNum = 0) {
+        if (this.client && this.client.status === 'ready') {
+            return this.client;
+        }
+        const defer = helper__namespace.getDefer();
+        let connection;
+        if (!helper__namespace.isEmpty(this.options.clusters)) {
+            connection = new IORedis__default["default"].Cluster([...this.options.clusters], { redisOptions: this.options });
+        }
+        else {
+            connection = new IORedis__default["default"](this.options);
+        }
+        connection.on('end', () => {
+            if (connNum < 3) {
+                connNum++;
+                defer.resolve(this.connect(connNum));
+            }
+            else {
+                this.close();
+                defer.reject('redis connection end');
+            }
+        });
+        connection.on('ready', () => {
+            this.client = connection;
+            defer.resolve(connection);
+        });
+        return defer.promise;
+    }
+    /**
+     * get connection from pool
+     *
+     * @returns {*}
+     * @memberof RedisStore
+     */
+    getConnection() {
+        if (!this.pool || !this.pool.acquire) {
+            const factory = {
+                create: () => {
+                    return this.connect();
+                },
+                destroy: () => {
+                    return this.close();
+                },
+                validate: (resource) => {
+                    return Promise.resolve(resource.status === 'ready');
+                }
+            };
+            this.pool = genericPool__default["default"].createPool(factory, {
+                max: this.options.poolSize || 10,
+                min: 2 // minimum size of the pool
+            });
+            this.pool.on('factoryCreateError', function (err) {
+                koatty_logger.DefaultLogger.Error(err);
+            });
+            this.pool.on('factoryDestroyError', function (err) {
+                koatty_logger.DefaultLogger.Error(err);
+            });
+        }
+        return this.pool.acquire();
+    }
+    /**
+     * close connection
+     *
+     * @returns {*}
+     * @memberof RedisStore
+     */
+    async close() {
+        this.client.disconnect();
+        this.client = null;
+        this.pool.destroy(this.client);
+        this.pool = null;
+        return;
+    }
+    /**
+     *
+     *
+     * @param {*} conn
+     * @returns {*}
+     * @memberof RedisStore
+     */
+    async release(conn) {
+        if (this.pool.isBorrowedResource(conn)) {
+            return this.pool.release(conn);
+        }
+        return Promise.resolve();
+    }
+    /**
+     * defineCommand
+     *
+     * @param {string} name
+     * @param {{ numberOfKeys?: number; lua?: string; }} scripts
+     * @returns {*}
+     * @memberof RedisStore
+     */
+    async defineCommand(name, scripts) {
+        const conn = await this.getConnection();
+        if (!conn[name]) {
+            conn.defineCommand(name, scripts);
+        }
+        return conn;
+    }
+    /**
+     * get and compare value
+     *
+     * @param {string} name
+     * @param {(string | number)} value
+     * @returns {*}  {Promise<any>}
+     * @memberof RedisStore
+     */
+    async getCompare(name, value) {
+        let conn;
+        try {
+            conn = await this.defineCommand("getCompare", {
+                numberOfKeys: 1,
+                lua: `
+                    local remote_value = redis.call("get",KEYS[1])
+                    
+                    if (not remote_value) then
+                        return 0
+                    elseif (remote_value == ARGV[1]) then
+                        return redis.call("del",KEYS[1])
+                    else
+                        return -1
+                    end
+            `
+            });
+            return conn.getCompare(name, value);
+        }
+        catch (error) {
+            throw error;
+        }
+        finally {
+            this.release(conn);
+        }
+    }
+}
+
+/**
+ *
+ *
+ * @export
+ * @class Store
+ */
+class Store {
+    /**
+     *
+     *
+     * @static
+     * @returns
+     * @memberof ValidateUtil
+     */
+    static getInstance(options) {
+        if (this.instance) {
+            return this.instance;
+        }
+        options = {
+            ...{
+                type: 'memory',
+                host: '',
+                port: 0,
+                keyPrefix: 'Koatty',
+                timeout: 600,
+                poolSize: 10,
+                connectTimeout: 500,
+                db: 0
+            }, ...options
+        };
+        switch (options.type) {
+            case "redis":
+                this.instance = new RedisStore(options);
+                break;
+            case "memory":
+            default:
+                this.instance = new MemoryStore(options);
+                break;
+        }
+        return this.instance;
+    }
+}
+
+exports.CacheStore = CacheStore;
+exports.MemoryStore = MemoryStore;
 exports.Store = Store;
-//# sourceMappingURL=index.js.map