koatty_store 1.5.8 → 1.6.0

package/dist/index.js

@@ -1,6 +1,6 @@
 /*!
 * @Author: richen
-* @Date: 2023-01-13 12:11:39
+* @Date: 2023-02-19 01:08:09
 * @License: BSD (3-Clause)
 * @Copyright (c) - <richenlin(at)gmail.com>
 * @HomePage: https://koatty.org/
@@ -11,7 +11,7 @@ var lodash = require('lodash');
 var helper = require('koatty_lib');
 var events = require('events');
 var koatty_logger = require('koatty_logger');
-var IORedis = require('ioredis');
+var ioredis = require('ioredis');
 var genericPool = require('generic-pool');
 
 function _interopNamespaceDefault(e) {
@@ -37,602 +37,592 @@ var helper__namespace = /*#__PURE__*/_interopNamespaceDefault(helper);
  * @Description:
  * @Usage:
  * @Author: richen
- * @Date: 2021-12-02 15:26:55
- * @LastEditTime: 2023-01-13 11:25:37
+ * @Date: 2021-12-02 11:03:20
+ * @LastEditTime: 2023-02-18 22:02:47
  */
 /**
  *
  *
- * @export
- * @class Store
+ * @enum {number}
  */
-class CacheStore {
+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 CacheStore.
-     * @param {StoreOptions} options
-     * @memberof CacheStore
+     * Creates an instance of MemoryCache.
+     * @param {*} options
+     * @memberof MemoryCache
      */
     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.");
+        super();
+        this.databases = Object.create({});
+        this.options = { ...{ database: "0" }, ...options };
+        this.currentDBIndex = 0;
+        this.connected = false;
+        this.lastSave = Date.now();
+        this.multiMode = false;
     }
     /**
-     * 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}
+     * @memberof MemoryCache
      */
-    set(name, value, timeout) {
-        if (typeof timeout !== 'number') {
-            timeout = this.options.timeout;
-        }
-        return this.wrap('set', [`${this.options.keyPrefix}${name}`, value, 'ex', timeout]);
+    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;
     }
     /**
-     * 以秒为单位，返回给定 key 的剩余生存时间
-     * @param name
+     *
+     *
      * @returns {*}
+     * @memberof MemoryCache
      */
-    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}`]);
+    quit() {
+        this.connected = false;
+        // exit multi mode if we are in it
+        this.discard(null, true);
+        this.emit('end');
+        return this;
     }
     /**
      *
      *
-     * @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 {*}
+     * @memberof MemoryCache
      */
-    decr(name) {
-        return this.wrap('decr', [`${this.options.keyPrefix}${name}`]);
+    end() {
+        return this.quit();
     }
     /**
-     * 将 key 所储存的值增加增量
-     * @param name
-     * @param incr
+     *
+     *
+     * @param {string} message
+     * @param {Function} [callback]
      * @returns {*}
+     * @memberof MemoryCache
      */
-    incrby(name, incr = 1) {
-        return this.wrap('incrby', [`${this.options.keyPrefix}${name}`, incr]);
+    echo(message, callback) {
+        return this._handleCallback(callback, message);
     }
     /**
-     * 将 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
+     *
+     * @param {string} message
+     * @param {Function} [callback]
+     * @returns {*}
+     * @memberof MemoryCache
      */
-    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);
+    ping(message, callback) {
+        message = message || messages.pong;
+        return this._handleCallback(callback, message);
     }
     /**
-     * 哈希获取
-     * @param name
-     * @param key
+     *
+     *
+     * @param {string} password
+     * @param {Function} [callback]
      * @returns {*}
+     * @memberof MemoryCache
      */
-    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;
-        });
+    auth(password, callback) {
+        return this._handleCallback(callback, messages.ok);
     }
     /**
-     * 查看哈希表 hashKey 中，给定域 key 是否存在
-     * @param name
-     * @param key
+     *
+     *
+     * @param {number} dbIndex
+     * @param {Function} [callback]
      * @returns {*}
+     * @memberof MemoryCache
      */
-    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;
-        });
+    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);
     }
     /**
-     * 哈希删除
-     * @param name
-     * @param key
+     * set(key, value, ttl, pttl, notexist, onlyexist, callback)
+     *
+     * @param {string} key
+     * @param {(string | number)} value
+     * @param {...any[]} params
      * @returns {*}
+     * @memberof MemoryCache
      */
-    hdel(name, key) {
-        const setP = [this.del(`${name}:${key}_ex`)];
-        setP.push(this.wrap('hdel', [`${this.options.keyPrefix}${name}`, key]));
-        return Promise.all(setP);
+    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);
     }
     /**
-     * 返回哈希表 key 中域的数量
-     * @param name
+     *
+     *
+     * @param {string} key
+     * @param {Function} [callback]
      * @returns {*}
+     * @memberof MemoryCache
      */
-    hlen(name) {
-        return this.wrap('hlen', [`${this.options.keyPrefix}${name}`]);
+    ttl(key, callback) {
+        let retVal = this.pttl(key);
+        if (retVal >= 0 || retVal <= -3) {
+            retVal = Math.floor(retVal / 1000);
+        }
+        return this._handleCallback(callback, retVal);
     }
     /**
-     * 给哈希表指定key，增加increment
-     * @param name
-     * @param key
-     * @param incr
+     *
+     *
+     * @param {string} key
+     * @param {number} seconds
+     * @param {Function} [callback]
      * @returns {*}
+     * @memberof MemoryCache
      */
-    hincrby(name, key, incr = 1) {
-        return this.wrap('hincrby', [`${this.options.keyPrefix}${name}`, key, incr]);
+    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);
     }
     /**
-     * 返回哈希表所有key-value
-     * @param name
+     *
+     *
+     * @param {...any[]} keys
      * @returns {*}
+     * @memberof MemoryCache
      */
-    hgetall(name) {
-        return this.wrap('hgetall', [`${this.options.keyPrefix}${name}`]);
+    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);
     }
     /**
-     * 返回哈希表所有key
-     * @param name
+     *
+     *
+     * @param {...any[]} keys
      * @returns {*}
+     * @memberof MemoryCache
      */
-    hkeys(name) {
-        return this.wrap('hkeys', [`${this.options.keyPrefix}${name}`]);
+    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);
     }
     /**
-     * 返回哈希表所有value
-     * @param name
+     *
+     *
+     * @param {string} key
+     * @param {Function} [callback]
      * @returns {*}
+     * @memberof MemoryCache
      */
-    hvals(name) {
-        return this.wrap('hvals', [`${this.options.keyPrefix}${name}`]);
+    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 name
+     *
+     *
+     * @param {string} key
+     * @param {number} amount
+     * @param {Function} [callback]
      * @returns {*}
+     * @memberof MemoryCache
      */
-    llen(name) {
-        return this.wrap('llen', [`${this.options.keyPrefix}${name}`]);
+    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 name
-     * @param value
+     *
+     *
+     * @param {string} key
+     * @param {Function} [callback]
      * @returns {*}
+     * @memberof MemoryCache
      */
-    rpush(name, value) {
-        return this.wrap('rpush', [`${this.options.keyPrefix}${name}`, value]);
+    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} name
-     * @param {(string | number)} value
+     * @param {string} key
+     * @param {number} amount
+     * @param {Function} [callback]
      * @returns {*}
-     * @memberof RedisStore
+     * @memberof MemoryCache
      */
-    lpush(name, value) {
-        return this.wrap('lpush', [`${this.options.keyPrefix}${name}`, value]);
+    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 name
+     *
+     *
+     * @param {string} key
+     * @param {string} field
+     * @param {Function} [callback]
      * @returns {*}
+     * @memberof MemoryCache
      */
-    lpop(name) {
-        return this.wrap('lpop', [`${this.options.keyPrefix}${name}`]);
+    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} name
+     * @param {string} key
+     * @param {string} field
+     * @param {Function} [callback]
      * @returns {*}
-     * @memberof RedisStore
+     * @memberof MemoryCache
      */
-    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: 2023-01-13 11:25:09
- */
-/**
- *
- *
- * @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;
+    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
      */
-    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;
+    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
      */
-    quit() {
-        this.connected = false;
-        // exit multi mode if we are in it
-        this.discard(null, true);
-        this.emit('end');
-        return this;
+    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
      */
-    end() {
-        return this.quit();
+    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} message
+     * @param {string} key
      * @param {Function} [callback]
      * @returns {*}
      * @memberof MemoryCache
      */
-    echo(message, callback) {
-        return this._handleCallback(callback, message);
+    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} message
+     * @param {string} key
      * @param {Function} [callback]
      * @returns {*}
      * @memberof MemoryCache
      */
-    ping(message, callback) {
-        message = message || messages.pong;
-        return this._handleCallback(callback, message);
+    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} password
+     * @param {string} key
      * @param {Function} [callback]
      * @returns {*}
      * @memberof MemoryCache
      */
-    auth(password, callback) {
-        return this._handleCallback(callback, messages.ok);
+    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 {number} dbIndex
+     * @param {string} key
+     * @param {(string | number)} value
      * @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;
+    rpush(key, value, callback) {
+        let retVal = 0;
         if (this._hasKey(key)) {
-            this._testType(key, 'string', true, callback);
-            retVal = this._getKey(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);
     }
     /**
-     * set(key, value, ttl, pttl, notexist, onlyexist, callback)
+     *
      *
      * @param {string} key
      * @param {(string | number)} value
-     * @param {...any[]} params
+     * @param {Function} [callback]
      * @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;
-        }
+    lpush(key, value, callback) {
+        let retVal = 0;
         if (this._hasKey(key)) {
-            this._testType(key, 'string', true, callback);
-            if (notexist) {
-                return this._handleCallback(callback, retVal);
-            }
+            this._testType(key, 'list', true, callback);
         }
-        else if (onlyexist) {
-            return this._handleCallback(callback, retVal);
+        else {
+            this.cache[key] = this._makeKey([], 'list');
         }
-        this.cache[key] = this._makeKey(value.toString(), 'string', pttl);
-        return this._handleCallback(callback, messages.ok);
+        const val = this._getKey(key);
+        val.splice(0, 0, value);
+        this._setKey(key, val);
+        retVal = val.length;
+        return this._handleCallback(callback, retVal);
     }
     /**
      *
@@ -642,10 +632,13 @@ class MemoryCache extends events.EventEmitter {
      * @returns {*}
      * @memberof MemoryCache
      */
-    ttl(key, callback) {
-        let retVal = this.pttl(key);
-        if (retVal >= 0 || retVal <= -3) {
-            retVal = Math.floor(retVal / 1000);
+    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);
     }
@@ -653,56 +646,83 @@ class MemoryCache extends events.EventEmitter {
      *
      *
      * @param {string} key
-     * @param {number} seconds
      * @param {Function} [callback]
      * @returns {*}
      * @memberof MemoryCache
      */
-    expire(key, seconds, callback) {
-        let retVal = 0;
+    rpop(key, callback) {
+        let retVal = null;
         if (this._hasKey(key)) {
-            this.cache[key].timeout = Date.now() + seconds * 1000;
-            retVal = 1;
+            this._testType(key, 'list', true, callback);
+            const val = this._getKey(key);
+            retVal = val.pop();
+            this._setKey(key, val);
         }
         return this._handleCallback(callback, retVal);
     }
     /**
      *
      *
-     * @param {...any[]} keys
+     * @param {string} key
+     * @param {number} start
+     * @param {number} stop
+     * @param {Function} [callback]
      * @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++;
+    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 {...any[]} keys
+     * @param {string} key
+     * @param {...any[]} members
      * @returns {*}
      * @memberof MemoryCache
      */
-    exists(...keys) {
+    sadd(key, ...members) {
         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++;
-            }
+        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);
     }
     /**
@@ -713,13 +733,11 @@ class MemoryCache extends events.EventEmitter {
      * @returns {*}
      * @memberof MemoryCache
      */
-    incr(key, callback) {
-        let retVal = null;
-        try {
-            retVal = this._addToKey(key, 1);
-        }
-        catch (err) {
-            return this._handleCallback(callback, null, err);
+    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);
     }
@@ -727,18 +745,19 @@ class MemoryCache extends events.EventEmitter {
      *
      *
      * @param {string} key
-     * @param {number} amount
+     * @param {string} member
      * @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);
+    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);
     }
@@ -750,13 +769,11 @@ class MemoryCache extends events.EventEmitter {
      * @returns {*}
      * @memberof MemoryCache
      */
-    decr(key, callback) {
-        let retVal = null;
-        try {
-            retVal = this._addToKey(key, -1);
-        }
-        catch (err) {
-            return this._handleCallback(callback, null, err);
+    smembers(key, callback) {
+        let retVal = [];
+        if (this._hasKey(key)) {
+            this._testType(key, 'set', true, callback);
+            retVal = this._getKey(key);
         }
         return this._handleCallback(callback, retVal);
     }
@@ -764,1146 +781,1113 @@ class MemoryCache extends events.EventEmitter {
      *
      *
      * @param {string} key
-     * @param {number} amount
+     * @param {number} [count]
      * @param {Function} [callback]
      * @returns {*}
      * @memberof MemoryCache
      */
-    decrby(key, amount, callback) {
+    spop(key, count, callback) {
         let retVal = null;
-        try {
-            retVal = this._addToKey(key, -amount);
-        }
-        catch (err) {
-            return this._handleCallback(callback, null, err);
+        count = count || 1;
+        if (isNaN(count)) {
+            return this._handleCallback(callback, null, messages.noint);
         }
-        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;
+            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());
+            }
         }
-        this._setField(key, field, value.toString());
-        this.persist(key);
         return this._handleCallback(callback, retVal);
     }
     /**
      *
      *
      * @param {string} key
-     * @param {string} field
-     * @param {Function} [callback]
+     * @param {...any[]} members
      * @returns {*}
      * @memberof MemoryCache
      */
-    hget(key, field, callback) {
-        let retVal = null;
+    srem(key, ...members) {
+        let retVal = 0;
+        const callback = this._retrieveCallback(members);
         if (this._hasKey(key)) {
-            this._testType(key, 'hash', true, callback);
-            if (this._hasField(key, field)) {
-                retVal = this._getKey(key)[field];
+            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} key
-     * @param {string} field
+     * @param {string} sourcekey
+     * @param {string} destkey
+     * @param {string} member
      * @param {Function} [callback]
      * @returns {*}
      * @memberof MemoryCache
      */
-    hexists(key, field, callback) {
+    smove(sourcekey, destkey, member, callback) {
         let retVal = 0;
-        if (this._hasKey(key)) {
-            this._testType(key, 'hash', true, callback);
-            if (this._hasField(key, field)) {
+        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.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 {...any[]} fields
+     * @param {Function} [callback]
      * @returns {*}
      * @memberof MemoryCache
      */
-    hdel(key, ...fields) {
-        let retVal = 0;
-        const callback = this._retrieveCallback(fields);
+    pttl(key, callback) {
+        let retVal = -2;
         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++;
+            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
      */
-    hlen(key, callback) {
-        const retVal = this.hkeys(key).length;
+    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
-     * @param {string} field
-     * @param {*} value
-     * @param {Function} [callback]
-     * @returns {*}
+     * @returns {*}  {boolean}
      * @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);
+    _hasKey(key) {
+        return this.cache.hasOwnProperty(key);
     }
     /**
      *
      *
-     * @param {string} key
-     * @param {Function} [callback]
+     * @private
+     * @param {*} value
+     * @param {string} type
+     * @param {number} timeout
      * @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);
+    _makeKey(value, type, timeout) {
+        return { value: value, type: type, timeout: timeout || null, lastAccess: Date.now() };
     }
     /**
      *
      *
+     * @private
      * @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);
+    _key(key) {
+        this.cache[key].lastAccess = Date.now();
+        return this.cache[key];
     }
-    // ---------------------------------------
-    // Lists (Array / Queue / Stack)
-    // ---------------------------------------
     /**
      *
      *
+     * @private
      * @param {string} key
+     * @param {number} amount
      * @param {Function} [callback]
      * @returns {*}
      * @memberof MemoryCache
      */
-    llen(key, callback) {
-        let retVal = 0;
+    _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, 'list', true, callback);
-            retVal = this._getKey(key).length || 0;
+            this._testType(key, 'string', true, callback);
+            keyValue = parseInt(this._getKey(key));
+            if (isNaN(keyValue) || lodash.isNil(keyValue)) {
+                return this._handleCallback(callback, null, messages.noint);
+            }
         }
-        return this._handleCallback(callback, retVal);
+        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 | number)} value
+     * @param {string} type
+     * @param {boolean} [throwError]
      * @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');
+    _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;
         }
-        const val = this._getKey(key);
-        val.push(value);
-        this._setKey(key, val);
-        retVal = val.length;
-        return this._handleCallback(callback, retVal);
+        return true;
     }
     /**
      *
      *
+     * @private
      * @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');
+    _getKey(key) {
+        const _key = this._key(key) || {};
+        if (_key.timeout && _key.timeout <= Date.now()) {
+            this.del(key);
+            return null;
         }
-        const val = this._getKey(key);
-        val.splice(0, 0, value);
-        this._setKey(key, val);
-        retVal = val.length;
-        return this._handleCallback(callback, retVal);
+        return _key.value;
     }
     /**
      *
      *
+     * @private
      * @param {string} key
-     * @param {Function} [callback]
-     * @returns {*}
+     * @param {(number | string)} value
      * @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);
+    _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
      */
-    rpop(key, callback) {
-        let retVal = null;
+    _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, 'list', true, callback);
-            const val = this._getKey(key);
-            retVal = val.pop();
-            this._setKey(key, val);
+            this._testType(key, 'hash', true, callback);
+            if (this._hasField(key, field)) {
+                value = this._getField(key, field);
+            }
         }
-        return this._handleCallback(callback, retVal);
+        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 {number} start
-     * @param {number} stop
-     * @param {Function} [callback]
+     * @param {string} field
      * @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);
+    _getField(key, field) {
+        return this._getKey(key)[field];
     }
-    // ---------------------------------------
-    // ## Sets (Unique Lists)##
-    // ---------------------------------------
     /**
      *
      *
+     * @private
      * @param {string} key
-     * @param {...any[]} members
-     * @returns {*}
+     * @param {string} field
+     * @returns {*}  {boolean}
      * @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');
+    _hasField(key, field) {
+        let retVal = false;
+        if (key && field) {
+            const ky = this._getKey(key);
+            if (ky) {
+                retVal = ky.hasOwnProperty(field);
+            }
         }
-        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);
+        return retVal;
     }
     /**
      *
      *
      * @param {string} key
-     * @param {Function} [callback]
-     * @returns {*}
+     * @param {string} field
+     * @param {*} value
      * @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);
+    _setField(key, field, value) {
+        this._getKey(key)[field] = value;
     }
     /**
      *
      *
-     * @param {string} key
-     * @param {string} member
+     * @private
      * @param {Function} [callback]
+     * @param {(any)} [message]
+     * @param {*} [error]
+     * @param {boolean} [nolog]
      * @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;
+    _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 this._handleCallback(callback, retVal);
+        return;
     }
     /**
      *
      *
-     * @param {string} key
-     * @param {Function} [callback]
+     * @private
+     * @param {any[]} [params]
      * @returns {*}
      * @memberof MemoryCache
      */
-    smembers(key, callback) {
-        let retVal = [];
-        if (this._hasKey(key)) {
-            this._testType(key, 'set', true, callback);
-            retVal = this._getKey(key);
+    _retrieveCallback(params) {
+        if (Array.isArray(params) && params.length > 0 && typeof params[params.length - 1] === 'function') {
+            return params.pop();
         }
-        return this._handleCallback(callback, retVal);
+        return;
+    }
+}
+
+/*
+ * @Description:
+ * @Usage:
+ * @Author: richen
+ * @Date: 2021-06-29 19:07:57
+ * @LastEditTime: 2023-02-18 23:52:47
+ */
+class MemoryStore {
+    /**
+     * Creates an instance of MemoryStore.
+     * @param {MemoryStoreOpt} options
+     * @memberof MemoryStore
+     */
+    constructor(options) {
+        this.options = options;
+        this.client = null;
     }
     /**
+     * getConnection
      *
-     *
-     * @param {string} key
-     * @param {number} [count]
-     * @param {Function} [callback]
      * @returns {*}
-     * @memberof MemoryCache
+     * @memberof MemoryStore
      */
-    spop(key, count, callback) {
-        let retVal = null;
-        count = count || 1;
-        if (isNaN(count)) {
-            return this._handleCallback(callback, null, messages.noint);
+    getConnection() {
+        if (!this.pool) {
+            this.pool = new MemoryCache({
+                database: this.options.db
+            });
         }
-        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());
-            }
+        if (!this.client) {
+            this.client = this.pool.createClient();
+            this.client.status = "ready";
         }
-        return this._handleCallback(callback, retVal);
+        return this.client;
     }
     /**
+     * close
      *
+     * @returns {*}  {Promise<void>}
+     * @memberof MemoryStore
+     */
+    async close() {
+        this.client.end();
+        this.client = null;
+    }
+    /**
+     * release
      *
-     * @param {string} key
-     * @param {...any[]} members
-     * @returns {*}
-     * @memberof MemoryCache
+     * @param {*} conn
+     * @returns {*}  {Promise<void>}
+     * @memberof MemoryStore
      */
-    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);
+    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} sourcekey
-     * @param {string} destkey
-     * @param {string} member
-     * @param {Function} [callback]
-     * @returns {*}
-     * @memberof MemoryCache
+     * @param {string} name
+     * @param {(string | number)} value
+     * @returns {*}  {Promise<any>}
+     * @memberof MemoryStore
      */
-    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;
-            }
+    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;
         }
-        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 ##
-    // ---------------------------------------
+}
+
+/*
+ * @Author: richen
+ * @Date: 2020-11-30 15:56:08
+ * @LastEditors: Please set LastEditors
+ * @LastEditTime: 2023-02-19 00:02:09
+ * @License: BSD (3-Clause)
+ * @Copyright (c) - <richenlin(at)gmail.com>
+ */
+/**
+ *
+ *
+ * @export
+ * @class RedisStore
+ */
+class RedisStore {
     /**
-     *
-     *
-     * @param {string} key
-     * @param {Function} [callback]
-     * @returns {*}
-     * @memberof MemoryCache
+     * Creates an instance of RedisStore.
+     * @param {RedisStoreOpt} options
+     * @memberof RedisStore
      */
-    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;
+    constructor(options) {
+        this.options = this.parseOpt(options);
+        this.pool = null;
+    }
+    // parseOpt
+    parseOpt(options) {
+        const opt = {
+            type: options.type,
+            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 {
-                retVal = -1;
+                // cluster
+                opt.host = "";
+                opt.port = null;
+                opt.clusters = [...hosts];
             }
         }
-        return this._handleCallback(callback, retVal);
+        return opt;
     }
     /**
+     * create connection by native
      *
-     *
-     * @private
-     * @param {string} key
-     * @param {Function} [callback]
-     * @returns {*}
-     * @memberof MemoryCache
+     * @param {number} [connNum=0]
+     * @returns {*}  {Promise<Redis | Cluster>}
+     * @memberof RedisStore
      */
-    persist(key, callback) {
-        let retVal = 0;
-        if (this._hasKey(key)) {
-            if (!lodash.isNil(this._key(key).timeout)) {
-                this._key(key).timeout = null;
-                retVal = 1;
-            }
+    async connect(connNum = 0) {
+        if (this.client && this.client.status === 'ready') {
+            return this.client;
         }
-        return this._handleCallback(callback, retVal);
-    }
-    /**
-     *
-     *
-     * @private
-     * @param {string} key
-     * @returns {*}  {boolean}
-     * @memberof MemoryCache
-     */
-    _hasKey(key) {
-        return this.cache.hasOwnProperty(key);
+        const defer = helper__namespace.getDefer();
+        let connection;
+        if (!helper__namespace.isEmpty(this.options.clusters)) {
+            connection = new ioredis.Cluster([...this.options.clusters], { redisOptions: this.options });
+        }
+        else {
+            connection = new ioredis.Redis(this.options);
+        }
+        // 去除prefix, 防止重复
+        this.options.keyPrefix = "";
+        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
      *
-     *
-     * @private
-     * @param {*} value
-     * @param {string} type
-     * @param {number} timeout
      * @returns {*}
-     * @memberof MemoryCache
+     * @memberof RedisStore
      */
-    _makeKey(value, type, timeout) {
-        return { value: value, type: type, timeout: timeout || null, lastAccess: Date.now() };
+    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.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
      *
-     *
-     * @private
-     * @param {string} key
      * @returns {*}
-     * @memberof MemoryCache
+     * @memberof RedisStore
      */
-    _key(key) {
-        this.cache[key].lastAccess = Date.now();
-        return this.cache[key];
+    async close() {
+        this.client.disconnect();
+        this.client = null;
+        this.pool.destroy(this.client);
+        this.pool = null;
+        return;
     }
     /**
      *
      *
-     * @private
-     * @param {string} key
-     * @param {number} amount
-     * @param {Function} [callback]
+     * @param {*} conn
      * @returns {*}
-     * @memberof MemoryCache
+     * @memberof RedisStore
      */
-    _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');
+    async release(conn) {
+        if (this.pool.isBorrowedResource(conn)) {
+            return this.pool.release(conn);
         }
-        const val = keyValue + amount;
-        this._setKey(key, val.toString());
-        return val;
+        return Promise.resolve();
     }
     /**
+     * defineCommand
      *
-     *
-     * @private
-     * @param {string} key
-     * @param {string} type
-     * @param {boolean} [throwError]
-     * @param {Function} [callback]
+     * @param {string} name
+     * @param {{ numberOfKeys?: number; lua?: string; }} scripts
      * @returns {*}
-     * @memberof MemoryCache
+     * @memberof RedisStore
      */
-    _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;
+    async defineCommand(name, scripts) {
+        const conn = await this.getConnection();
+        if (!conn[name]) {
+            conn.defineCommand(name, scripts);
         }
-        return true;
+        return conn;
     }
     /**
+     * get and compare value
      *
-     *
-     * @private
-     * @param {string} key
-     * @returns {*}
-     * @memberof MemoryCache
+     * @param {string} name
+     * @param {(string | number)} value
+     * @returns {*}  {Promise<any>}
+     * @memberof RedisStore
      */
-    _getKey(key) {
-        const _key = this._key(key) || {};
-        if (_key.timeout && _key.timeout <= Date.now()) {
-            this.del(key);
-            return null;
+    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);
+        }
+    }
+}
+
+/*
+ * @Description:
+ * @Usage:
+ * @Author: richen
+ * @Date: 2021-12-02 15:26:55
+ * @LastEditTime: 2023-02-19 01:03:59
+ */
+const defaultOptions = {
+    type: 'memory',
+    host: '',
+    port: 0,
+    keyPrefix: 'Koatty',
+    timeout: 600,
+    poolSize: 10,
+    connectTimeout: 500,
+    db: 0
+};
+/**
+ *
+ *
+ * @export
+ * @class Store
+ */
+class CacheStore {
+    /**
+     * Creates an instance of CacheStore.
+     * @param {StoreOptions} options
+     * @memberof CacheStore
+     */
+    constructor(options) {
+        this.options = { ...defaultOptions, ...options };
+        this.client = null;
+        switch (options.type) {
+            case "redis":
+                this.client = new RedisStore(options);
+                break;
+            case "memory":
+            default:
+                this.client = new MemoryStore(options);
+                break;
         }
-        return _key.value;
     }
     /**
      *
      *
-     * @private
-     * @param {string} key
-     * @param {(number | string)} value
-     * @memberof MemoryCache
+     * @static
+     * @returns
      */
-    _setKey(key, value) {
-        this.cache[key].value = value;
-        this.cache[key].lastAccess = Date.now();
+    static getInstance(options) {
+        if (this.instance) {
+            return this.instance;
+        }
+        this.instance = new CacheStore(options);
+        return this.instance;
+    }
+    getConnection() {
+        return this.client.getConnection();
+    }
+    close() {
+        return this.client.close();
+    }
+    release(conn) {
+        return this.client.release(conn);
+    }
+    defineCommand(name, scripts) {
+        return this.client.defineCommand(name, scripts);
+    }
+    getCompare(name, value) {
+        return this.client.getCompare(name, value);
     }
     /**
+     * handler for native client
      *
-     *
-     * @private
-     * @param {string} key
-     * @param {string} field
-     * @param {number} [amount]
-     * @param {boolean} [useFloat]
-     * @param {Function} [callback]
+     * @param {string} name
+     * @param {any[]} data
      * @returns {*}
-     * @memberof MemoryCache
+     * @memberof RedisStore
      */
-    _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);
-            }
+    async wrap(name, data) {
+        let conn;
+        try {
+            conn = await this.getConnection();
+            const res = await conn[name](...data);
+            return res;
         }
-        else {
-            this.cache[key] = this._makeKey({}, 'hash');
+        catch (err) {
+            throw err;
         }
-        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);
+        finally {
+            this.release(conn);
         }
-        fieldValue += amount;
-        this._setField(key, field, fieldValue.toString());
-        return fieldValue;
     }
     /**
-     *
-     *
-     * @private
-     * @param {string} key
-     * @param {string} field
-     * @returns {*}
-     * @memberof MemoryCache
+     * 字符串获取
+     * @param name
      */
-    _getField(key, field) {
-        return this._getKey(key)[field];
+    get(name) {
+        return this.wrap('get', [`${this.options.keyPrefix || ""}${name}`]);
     }
     /**
-     *
-     *
-     * @private
-     * @param {string} key
-     * @param {string} field
-     * @returns {*}  {boolean}
-     * @memberof MemoryCache
+     * 字符串写入
+     * @param name
+     * @param value
+     * @param timeout
+     * @returns {Promise}
      */
-    _hasField(key, field) {
-        let retVal = false;
-        if (key && field) {
-            const ky = this._getKey(key);
-            if (ky) {
-                retVal = ky.hasOwnProperty(field);
-            }
+    set(name, value, timeout) {
+        if (typeof timeout !== 'number') {
+            timeout = this.options.timeout;
         }
-        return retVal;
+        return this.wrap('set', [`${this.options.keyPrefix || ""}${name}`, value, 'ex', timeout]);
     }
     /**
-     *
-     *
-     * @param {string} key
-     * @param {string} field
-     * @param {*} value
-     * @memberof MemoryCache
+     * 以秒为单位，返回给定 key 的剩余生存时间
+     * @param name
+     * @returns {*}
      */
-    _setField(key, field, value) {
-        this._getKey(key)[field] = value;
+    ttl(name) {
+        return this.wrap('ttl', [`${this.options.keyPrefix || ""}${name}`]);
     }
     /**
-     *
-     *
-     * @private
-     * @param {Function} [callback]
-     * @param {(any)} [message]
-     * @param {*} [error]
-     * @param {boolean} [nolog]
-     * @returns {*}
-     * @memberof MemoryCache
+     * 设置key超时属性
+     * @param name
+     * @param timeout
      */
-    _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;
+    expire(name, timeout) {
+        return this.wrap('expire', [`${this.options.keyPrefix || ""}${name}`, timeout]);
     }
-    _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;
+    /**
+     * 删除key
+     * @param name
+     */
+    rm(name) {
+        return this.wrap('del', [`${this.options.keyPrefix || ""}${name}`]);
     }
     /**
      *
      *
-     * @private
-     * @param {any[]} [params]
-     * @returns {*}
-     * @memberof MemoryCache
+     * @param {*} name
+     * @returns
      */
-    _retrieveCallback(params) {
-        if (Array.isArray(params) && params.length > 0 && typeof params[params.length - 1] === 'function') {
-            return params.pop();
-        }
-        return;
+    del(name) {
+        return this.wrap('del', [`${this.options.keyPrefix || ""}${name}`]);
     }
-}
-
-// const MemoryCache = require('@outofsync/memory-cache');
-/*
- * @Description:
- * @Usage:
- * @Author: richen
- * @Date: 2021-06-29 19:07:57
- * @LastEditTime: 2023-01-13 11:25:19
- */
-class MemoryStore extends CacheStore {
     /**
-     * Creates an instance of MemoryStore.
-     * @param {StoreOptions} options
-     * @memberof MemoryStore
+     * 判断key是否存在
+     * @param name
      */
-    constructor(options) {
-        super(options);
-        this.options = options;
-        this.client = null;
+    exists(name) {
+        return this.wrap('exists', [`${this.options.keyPrefix || ""}${name}`]);
     }
     /**
-     * getConnection
-     *
-     * @returns {*}
-     * @memberof MemoryStore
+     * 自增
+     * @param name
      */
-    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;
+    incr(name) {
+        return this.wrap('incr', [`${this.options.keyPrefix || ""}${name}`]);
     }
     /**
-     * close
-     *
-     * @returns {*}  {Promise<void>}
-     * @memberof MemoryStore
+     * 自减
+     * @param name
+     * @returns {*}
      */
-    async close() {
-        this.client.end();
-        this.client = null;
+    decr(name) {
+        return this.wrap('decr', [`${this.options.keyPrefix || ""}${name}`]);
     }
     /**
-     * release
-     *
-     * @param {*} conn
-     * @returns {*}  {Promise<void>}
-     * @memberof MemoryStore
+     * 将 key 所储存的值增加增量
+     * @param name
+     * @param incr
+     * @returns {*}
      */
-    async release(conn) {
-        return;
+    incrby(name, incr = 1) {
+        return this.wrap('incrby', [`${this.options.keyPrefix || ""}${name}`, incr]);
     }
     /**
-     * defineCommand
+     * 将 key 所储存的值减去减量
      *
-     * @param {string} name
-     * @param {*} scripts
-     * @memberof MemoryStore
+     * @param {any} name
+     * @param {any} decr
      */
-    async defineCommand(name, scripts) {
-        throw new Error(messages.unsupported);
+    decrby(name, decr = 1) {
+        return this.wrap('decrby', [`${this.options.keyPrefix || ""}${name}`, decr]);
     }
     /**
-     * get and compare value
-     *
-     * @param {string} name
-     * @param {(string | number)} value
-     * @returns {*}  {Promise<any>}
-     * @memberof MemoryStore
+     * 哈希写入
+     * @param name
+     * @param key
+     * @param value
+     * @param timeout
      */
-    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;
+    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);
     }
-}
-
-/*
- * @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
+     * 哈希获取
+     * @param name
+     * @param key
+     * @returns {*}
      */
-    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];
+    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 opt;
+            return dataArr[1] || null;
+        });
     }
     /**
-     * create connection by native
-     *
-     * @param {number} [connNum=0]
-     * @returns {*}  {Promise<IORedis.Redis | IORedis.Cluster>}
-     * @memberof RedisStore
+     * 查看哈希表 hashKey 中，给定域 key 是否存在
+     * @param name
+     * @param key
+     * @returns {*}
      */
-    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.Cluster([...this.options.clusters], { redisOptions: this.options });
-        }
-        else {
-            connection = new IORedis(this.options);
-        }
-        connection.on('end', () => {
-            if (connNum < 3) {
-                connNum++;
-                defer.resolve(this.connect(connNum));
-            }
-            else {
-                this.close();
-                defer.reject('redis connection end');
+    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;
         });
-        connection.on('ready', () => {
-            this.client = connection;
-            defer.resolve(connection);
-        });
-        return defer.promise;
     }
     /**
-     * get connection from pool
-     *
+     * 哈希删除
+     * @param name
+     * @param key
      * @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.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();
+    hdel(name, key) {
+        const setP = [this.del(`${name}:${key}_ex`)];
+        setP.push(this.wrap('hdel', [`${this.options.keyPrefix || ""}${name}`, key]));
+        return Promise.all(setP);
     }
     /**
-     * close connection
-     *
+     * 返回哈希表 key 中域的数量
+     * @param name
      * @returns {*}
-     * @memberof RedisStore
      */
-    async close() {
-        this.client.disconnect();
-        this.client = null;
-        this.pool.destroy(this.client);
-        this.pool = null;
-        return;
+    hlen(name) {
+        return this.wrap('hlen', [`${this.options.keyPrefix || ""}${name}`]);
     }
     /**
-     *
-     *
-     * @param {*} conn
+     * 给哈希表指定key，增加increment
+     * @param name
+     * @param key
+     * @param incr
      * @returns {*}
-     * @memberof RedisStore
      */
-    async release(conn) {
-        if (this.pool.isBorrowedResource(conn)) {
-            return this.pool.release(conn);
-        }
-        return Promise.resolve();
+    hincrby(name, key, incr = 1) {
+        return this.wrap('hincrby', [`${this.options.keyPrefix || ""}${name}`, key, incr]);
     }
     /**
-     * defineCommand
-     *
-     * @param {string} name
-     * @param {{ numberOfKeys?: number; lua?: string; }} scripts
+     * 返回哈希表所有key-value
+     * @param name
      * @returns {*}
-     * @memberof RedisStore
      */
-    async defineCommand(name, scripts) {
-        const conn = await this.getConnection();
-        if (!conn[name]) {
-            conn.defineCommand(name, scripts);
-        }
-        return conn;
+    hgetall(name) {
+        return this.wrap('hgetall', [`${this.options.keyPrefix || ""}${name}`]);
     }
     /**
-     * get and compare value
+     * 返回哈希表所有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 {*}  {Promise<any>}
+     * @returns {*}
      * @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);
-        }
+    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}`]);
     }
-}
-
-/**
- *
- *
- * @export
- * @class Store
- */
-class Store {
     /**
      *
      *
-     * @static
-     * @returns
-     * @memberof ValidateUtil
+     * @param {string} name
+     * @returns {*}
+     * @memberof RedisStore
      */
-    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;
+    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 this.instance;
+        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]);
     }
 }
 
 exports.CacheStore = CacheStore;
-exports.MemoryStore = MemoryStore;
-exports.Store = Store;