@maiyunnet/kebab 3.2.35 → 4.0.0

package/lib/kv.js

@@ -1,708 +1,69 @@
 /**
  * Project: Kebab, User: JianSuoQiYue
  * Date: 2019-5-30 19:25:22
- * Last: 2020-3-28 18:54:04, 2022-09-12 23:24:45, 2022-09-22 01:06:22, 2024-2-21 13:32:56, 2024-8-21 16:59:57
+ * Last: 2020-3-28 18:54:04, 2022-09-12 23:24:45, 2022-09-22 01:06:22, 2024-2-21 13:32:56, 2024-8-21 16:59:57, 2025-11-6 14:56:45
  */
-// --- Pool 是使用时必须要一个用户创建一份的，Connection 是池子里获取的 ---
-// --- 为啥 Pool 要独立，因为有些配置项目不能存在 Connection 是用户单独使用的，例如 pre ---
 // --- 第三方 ---
 import * as redis from '@litert/redis';
-import * as lTime from '#kebab/lib/time.js';
+// --- 库和定义 ---
 import * as lText from '#kebab/lib/text.js';
 import * as lCore from '#kebab/lib/core.js';
-/** --- 连接列表（同一个 host、port、index、auth 只有一个连接） --- */
+/** --- 连接列表（同一个 host、port、index 只有一个连接） --- */
 const connections = [];
-/**
- * --- 计划任务 10 秒一次，关闭超过 30 秒不活动的连接 ---
- */
-async function checkConnection() {
-    const now = lTime.stamp();
-    for (let i = 0; i < connections.length; ++i) {
-        const connection = connections[i];
-        if (connection.isLost()) {
-            // --- 连接已经丢失，移除 ---
-            await connection.end();
-            connections.splice(i, 1);
-            --i;
-            continue;
-        }
-        if (connection.isUsing()) {
-            // --- 连接正在被使用，看看是否使用超过 30 秒，超过则不是正常状态 ---
-            if (connection.getLast() <= now - 30) {
-                // --- 30 秒之前开始的 ---
-                const msg = `[KV][checkConnection] There is a transactional connection[${i}] that is not closed.`;
-                lCore.display(msg);
-                lCore.log({}, msg, '-error');
-                await connection.end();
-                connections.splice(i, 1);
-                --i;
-            }
-            continue;
-        }
-        if (connection.getLast() <= now - 30) {
-            // --- 超 30 秒未被使用，则关闭 ---
-            await connection.end();
-            connections.splice(i, 1);
-            --i;
-            continue;
-        }
-        // --- 30 秒内使用过，看看连接是否正常 ---
-        if (await connection.ping(false)) {
-            // --- 正常 ---
-            continue;
-        }
-        // --- 连接有问题，直接关闭 ---
-        await connection.end();
-        connections.splice(i, 1);
-        --i;
-    }
-    setTimeout(function () {
-        checkConnection().catch(() => { });
-    }, 10_000);
-}
-setTimeout(function () {
-    checkConnection().catch(() => { });
-}, 10_000);
-export class Pool {
+export class Kv {
     constructor(ctr, etc) {
         const configKv = ctr.getPrototype('_config').kv;
-        this._etc = {
-            'host': etc?.host ?? configKv.host,
-            'port': etc?.port ?? configKv.port,
-            'index': etc?.index ?? configKv.index,
-            'pre': etc?.pre ?? configKv.pre,
-            'user': etc?.user ?? configKv.user,
-            'pwd': etc?.pwd ?? configKv.pwd,
-        };
-    }
-    /**
-     * --- 设定一个值 ---
-     * @param key
-     * @param val
-     * @param ttl 秒，0 为不限制
-     * @param mod 设置模式: 空,nx（key不存在才建立）,xx（key存在才修改）
-     */
-    async set(key, val, ttl = 0, mod = '') {
-        const conn = await this._getConnection();
-        if (!conn) {
-            return false;
-        }
-        const r = await conn.set(key, val, ttl, mod, this._etc);
-        conn.used();
-        return r;
-    }
-    /**
-     * --- 添加一个值，存在则不变 ---
-     * @param key
-     * @param val
-     * @param ttl 秒，0 为不限制
-     */
-    async add(key, val, ttl = 0) {
-        const conn = await this._getConnection();
-        if (!conn) {
-            return false;
-        }
-        const r = await conn.add(key, val, ttl, this._etc);
-        conn.used();
-        return r;
-    }
-    /**
-     * --- 替换一个存在的值 ---
-     * @param key
-     * @param val
-     * @param ttl 秒，0 为不限制
-     */
-    async replace(key, val, ttl = 0) {
-        const conn = await this._getConnection();
-        if (!conn) {
-            return false;
-        }
-        const r = await conn.replace(key, val, ttl, this._etc);
-        conn.used();
-        return r;
-    }
-    /**
-     * --- 向已存在的值后追加数据 ---
-     * @param key
-     * @param val
-     */
-    async append(key, val) {
-        const conn = await this._getConnection();
-        if (!conn) {
-            return false;
-        }
-        const r = await conn.append(key, val, this._etc);
-        conn.used();
-        return r;
-    }
-    /**
-     * --- 向已存在的值之前追加数据 ---
-     * @param key
-     * @param val
-     */
-    async prepend(key, val) {
-        const conn = await this._getConnection();
-        if (!conn) {
-            return false;
-        }
-        const r = await conn.prepend(key, val, this._etc);
-        conn.used();
-        return r;
-    }
-    /**
-     * --- 检测 key 是否存在 ---
-     * @param keys
-     */
-    async exists(keys) {
-        const conn = await this._getConnection();
-        if (!conn) {
-            return 0;
-        }
-        const r = await conn.exists(keys, this._etc);
-        conn.used();
-        return r;
-    }
-    /**
-     * --- 获取字符串 ---
-     * @param key
-     */
-    async get(key) {
-        const conn = await this._getConnection();
-        if (!conn) {
-            return null;
-        }
-        const r = await conn.get(key, this._etc);
-        conn.used();
-        return r;
-    }
-    /**
-     * --- 获取相应的剩余有效期秒数 ---
-     * @param key
-     */
-    async ttl(key) {
-        const conn = await this._getConnection();
-        if (!conn) {
-            return null;
-        }
-        const r = await conn.ttl(key, this._etc);
-        conn.used();
-        return r;
-    }
-    /**
-     * --- 获取相应的剩余有效期毫秒数 ---
-     * @param key
-     */
-    async pttl(key) {
-        const conn = await this._getConnection();
-        if (!conn) {
-            return null;
-        }
-        const r = await conn.pttl(key, this._etc);
-        conn.used();
-        return r;
-    }
-    /**
-     * --- 批量获取值 ---
-     * @param keys key 序列
-     */
-    async mSet(rows) {
-        const conn = await this._getConnection();
-        if (!conn) {
-            return false;
+        const host = etc?.host ?? configKv.host;
+        const port = etc?.port ?? configKv.port;
+        this._index = etc?.index ?? configKv.index;
+        this._pre = etc?.pre ?? configKv.pre;
+        const item = connections.find(item => (item.host === host) && (item.port === port) && (item.index === this._index));
+        if (item) {
+            this._new = false;
+            this._link = item.link;
+            return;
         }
-        const r = await conn.mSet(rows, this._etc);
-        conn.used();
-        return r;
+        this._new = true;
+        this._link = redis.createCommandClient({
+            'host': host,
+            'port': port,
+        });
+        this._link.on('error', err => {
+            lCore.debug('[KV][constructor][error]', err);
+        }).on('end', () => {
+            // --- 连接断开，不过没关系，执行命令时会自动重连 ---
+        }).on('close', () => {
+            // --- 连接断开，不过没关系，执行命令时会自动重连 ---
+        });
+        connections.push({
+            'host': host,
+            'port': port,
+            'index': this._index,
+            'link': this._link,
+        });
     }
-    /**
-     * --- 批量获取值 ---
-     * @param keys key 序列
-     */
-    async mGet(keys) {
-        const conn = await this._getConnection();
-        if (conn) {
-            const r = await conn.mGet(keys, this._etc);
-            conn.used();
-            return r;
-        }
-        else {
-            const rtn = {};
-            for (const key of keys) {
-                rtn[key] = null;
+    /** --- 初始化连接 --- */
+    async init(ctr, etc) {
+        try {
+            if (!this._new) {
+                // --- 不是新连接，不需要初始化 ---
+                return true;
             }
-            return rtn;
-        }
-    }
-    /**
-     * --- 获取 json 对象 ---
-     * @param key
-     * @returns false 表示系统错误, null 表示不存在, 其他值为 json 对象
-     */
-    async getJson(key) {
-        const conn = await this._getConnection();
-        if (!conn) {
-            return false;
-        }
-        const r = await conn.getJson(key, this._etc);
-        conn.used();
-        return r;
-    }
-    /**
-     * --- 删除已存在的值 ---
-     * @param keys
-     */
-    async del(keys) {
-        const conn = await this._getConnection();
-        if (!conn) {
-            return false;
-        }
-        const r = await conn.del(keys, this._etc);
-        conn.used();
-        return r;
-    }
-    /**
-     * --- 自增 ---
-     * @param key
-     * @param num 整数或浮点正数
-     */
-    async incr(key, num = 1) {
-        const conn = await this._getConnection();
-        if (!conn) {
-            return false;
-        }
-        const r = await conn.incr(key, num, this._etc);
-        conn.used();
-        return r;
-    }
-    /**
-     * --- 自减 ---
-     * @param key
-     * @param num 整数或浮点正数
-     */
-    async decr(key, num = 1) {
-        const conn = await this._getConnection();
-        if (!conn) {
-            return false;
-        }
-        const r = await conn.decr(key, num, this._etc);
-        conn.used();
-        return r;
-    }
-    /**
-     * --- 仅修改过期时间不修改值 ---
-     * @param key
-     * @param ttl
-     */
-    async expire(key, ttl) {
-        const conn = await this._getConnection();
-        if (!conn) {
-            return false;
-        }
-        const r = await conn.expire(key, ttl, this._etc);
-        conn.used();
-        return r;
-    }
-    /**
-     * --- 获取服务器上的所有 key 列表 ---
-     * @param pattern
-     */
-    async keys(pattern) {
-        const conn = await this._getConnection();
-        if (!conn) {
-            return false;
-        }
-        const r = await conn.keys(pattern, this._etc);
-        conn.used();
-        return r;
-    }
-    /**
-     * --- 根据条件获取服务器上的 keys ---
-     * @param cursor
-     * @param pattern 例如 *
-     * @param count 获取的条数
-     */
-    async scan(cursor = 0, pattern = '*', count = 10) {
-        const conn = await this._getConnection();
-        if (!conn) {
-            return false;
-        }
-        const r = await conn.scan(cursor, pattern, count, this._etc);
-        conn.used();
-        return r;
-    }
-    /**
-     * --- 清除当前所选数据库的所有内容 ---
-     */
-    async flushDb() {
-        const conn = await this._getConnection();
-        if (!conn) {
-            return false;
-        }
-        const r = await conn.flushDb();
-        conn.used();
-        return r;
-    }
-    /**
-     * --- 发送 ping ---
-     */
-    async ping() {
-        const conn = await this._getConnection();
-        if (!conn) {
-            return false;
-        }
-        const r = await conn.ping();
-        conn.used();
-        return r;
-    }
-    /**
-     * --- 设置哈希表值 ---
-     * @param key key 名
-     * @param field 字段名
-     * @param val 值
-     * @param mod 空,nx(key不存在才建立)
-     */
-    async hSet(key, field, val, mod = '') {
-        const conn = await this._getConnection();
-        if (!conn) {
-            return false;
-        }
-        const r = await conn.hSet(key, field, val, mod, this._etc);
-        conn.used();
-        return r;
-    }
-    /**
-     * --- 批量设置哈希值 ---
-     * @param key key 名
-     * @param rows key / val 数组
-     */
-    async hMSet(key, rows) {
-        const conn = await this._getConnection();
-        if (!conn) {
-            return false;
-        }
-        const r = await conn.hMSet(key, rows, this._etc);
-        conn.used();
-        return r;
-    }
-    /**
-     * --- 获取哈希值 ---
-     * @param key
-     * @param field
-     */
-    async hGet(key, field) {
-        const conn = await this._getConnection();
-        if (!conn) {
-            return null;
-        }
-        const r = await conn.hGet(key, field, this._etc);
-        conn.used();
-        return r;
-    }
-    /**
-     * --- 获取哈希 json 对象 ---
-     * @param key
-     * @param field
-     */
-    async hGetJson(key, field) {
-        const conn = await this._getConnection();
-        if (!conn) {
-            return null;
-        }
-        const r = await conn.hGetJson(key, field, this._etc);
-        conn.used();
-        return r;
-    }
-    /**
-     * --- 批量获取哈希值 ---
-     * @param key
-     * @param fields
-     */
-    async hMGet(key, fields) {
-        const conn = await this._getConnection();
-        if (conn) {
-            const r = await conn.hMGet(key, fields, this._etc);
-            conn.used();
-            return r;
+            const configKv = ctr.getPrototype('_config').kv;
+            const user = etc?.user ?? configKv.user;
+            const pwd = etc?.pwd ?? configKv.pwd;
+            await this._link.auth(pwd, user || undefined);
+            await this._link.select(this._index);
+            return true;
         }
-        else {
-            const rtn = {};
-            for (const field of fields) {
-                rtn[field] = null;
+        catch {
+            // --- 初始化失败，移除 ---
+            const item = connections.findIndex(item => item.link === this._link);
+            if (item !== -1) {
+                connections.splice(item, 1);
             }
-            return rtn;
-        }
-    }
-    /**
-     * --- 批量获取哈希键值对 ---
-     * @param key
-     */
-    async hGetAll(key) {
-        const conn = await this._getConnection();
-        if (!conn) {
-            return null;
-        }
-        const r = await conn.hGetAll(key, this._etc);
-        conn.used();
-        return r;
-    }
-    /**
-     * --- 删除哈希键 ---
-     * @param key
-     * @param fields 值序列
-     */
-    async hDel(key, fields) {
-        const conn = await this._getConnection();
-        if (!conn) {
-            return 0;
-        }
-        const r = await conn.hDel(key, fields, this._etc);
-        conn.used();
-        return r;
-    }
-    /**
-     * --- 判断哈希字段是否存在 ---
-     * @param key
-     * @param field
-     */
-    async hExists(key, field) {
-        const conn = await this._getConnection();
-        if (!conn) {
             return false;
         }
-        const r = await conn.hExists(key, field, this._etc);
-        conn.used();
-        return r;
-    }
-    /**
-     * --- 设置哈希自增自减 ---
-     * @param key key
-     * @param field 字段
-     * @param increment 正数或负数，整数或浮点
-     */
-    async hIncr(key, field, increment) {
-        const conn = await this._getConnection();
-        if (!conn) {
-            return 0;
-        }
-        const r = await conn.hIncr(key, field, increment, this._etc);
-        conn.used();
-        return r;
-    }
-    /**
-     * --- 获取哈希所有字段 ---
-     * @param key
-     */
-    async hKeys(key) {
-        const conn = await this._getConnection();
-        if (!conn) {
-            return [];
-        }
-        const r = await conn.hKeys(key, this._etc);
-        conn.used();
-        return r;
-    }
-    async lPush(key, values) {
-        const conn = await this._getConnection();
-        if (!conn) {
-            return 0;
-        }
-        const r = await conn.lPush(key, values, this._etc);
-        conn.used();
-        return r;
-    }
-    async rPush(key, values) {
-        const conn = await this._getConnection();
-        if (!conn) {
-            return 0;
-        }
-        const r = await conn.rPush(key, values, this._etc);
-        conn.used();
-        return r;
-    }
-    async bLMove(sourceKey, destKey, soo, deo, timeout) {
-        const conn = await this._getConnection();
-        if (!conn) {
-            return null;
-        }
-        const r = await conn.bLMove(sourceKey, destKey, soo, deo, timeout, this._etc);
-        conn.used();
-        return r;
-    }
-    async lPop(key) {
-        const conn = await this._getConnection();
-        if (!conn) {
-            return null;
-        }
-        const r = await conn.lPop(key, this._etc);
-        conn.used();
-        return r;
-    }
-    async rPop(key) {
-        const conn = await this._getConnection();
-        if (!conn) {
-            return null;
-        }
-        const r = await conn.rPop(key, this._etc);
-        conn.used();
-        return r;
-    }
-    async bRPop(key, timeout) {
-        const conn = await this._getConnection();
-        if (!conn) {
-            return {};
-        }
-        const r = await conn.bRPop(key, timeout, this._etc);
-        conn.used();
-        return r;
-    }
-    async lRange(key, start, stop) {
-        const conn = await this._getConnection();
-        if (!conn) {
-            return [];
-        }
-        const r = await conn.lRange(key, start, stop, this._etc);
-        conn.used();
-        return r;
-    }
-    async lLen(key) {
-        const conn = await this._getConnection();
-        if (!conn) {
-            return 0;
-        }
-        const r = await conn.lLen(key, this._etc);
-        conn.used();
-        return r;
-    }
-    /**
-     * --- 从连接池获取一个连接，会被自动设置为使用中，需要在执行命令后解除占用 ---
-     */
-    async _getConnection() {
-        let conn;
-        for (const connection of connections) {
-            const etc = connection.getEtc();
-            if (connection.isLost() ||
-                connection.isUsing() ||
-                (etc.host !== this._etc.host) ||
-                (etc.port !== this._etc.port) ||
-                (etc.index !== this._etc.index)) {
-                // --- 配置项连接项不匹配 ---
-                continue;
-            }
-            connection.refreshLast();
-            connection.setUsing();
-            conn = connection;
-            break;
-        }
-        if (!conn) {
-            // --- 没有找到合适的连接，创建一个 ---
-            const link = redis.createCommandClient({
-                'host': this._etc.host,
-                'port': this._etc.port,
-            });
-            // --- 开始连接 ---
-            try {
-                await link.connect();
-            }
-            catch {
-                return null;
-            }
-            // --- 认证 ---
-            if (this._etc.user || this._etc.pwd) {
-                try {
-                    await link.auth(this._etc.user + this._etc.pwd);
-                }
-                catch {
-                    return null;
-                }
-            }
-            await link.select(this._etc.index);
-            conn = new Connection(this._etc, link);
-            conn.refreshLast();
-            conn.setUsing();
-            link.on('error', function (err) {
-                conn.setLost();
-                // console.log(`--- redis [${conn._etc.host}:${conn._etc.port}] error ---`);
-                lCore.debug('[KV][_getConnection][error]', err);
-            }).on('end', () => {
-                conn.setLost();
-            }).on('close', () => {
-                conn.setLost();
-            });
-            connections.push(conn);
-        }
-        return conn;
-    }
-}
-export class Connection {
-    constructor(etc, link) {
-        /** --- 本连接最后一次使用时间 --- */
-        this._last = 0;
-        /** --- 当前连接是否正在被独占使用 --- */
-        this._using = false;
-        /** --- 当发生断开，则需从连接池移除连接 --- */
-        this._lost = false;
-        this._etc = etc;
-        this._link = link;
-        this.refreshLast();
-    }
-    /**
-     * --- 获取连接 etc 信息 ---
-     */
-    getEtc() {
-        return this._etc;
-    }
-    /**
-     * --- 获取最后一次获取连接的时间 ---
-     */
-    getLast() {
-        return this._last;
-    }
-    /**
-     * --- 将本条连接设置为不可用 ---
-     */
-    setLost() {
-        this._lost = true;
-    }
-    /**
-     * --- 是否已经丢失 ---
-     */
-    isLost() {
-        return this._lost;
-    }
-    /**
-     * --- 将本条连接设置占用中 ---
-     */
-    setUsing() {
-        this._using = true;
-    }
-    /**
-     * --- 获取当前状态是否正在被使用中 ---
-     */
-    isUsing() {
-        return this._using;
-    }
-    /**
-     * --- 取消占用 ---
-     */
-    used() {
-        this._using = false;
-    }
-    /**
-     * --- 设定最后使用时间 ---
-     */
-    refreshLast() {
-        this._last = lTime.stamp();
-    }
-    /**
-     * --- 断开此连接，一般情况下不使用 ---
-     */
-    async end() {
-        try {
-            await this._link.close();
-        }
-        catch {
-            return;
-        }
     }
     /**
      * --- 设定一个值 ---
@@ -710,23 +71,21 @@ export class Connection {
      * @param val
      * @param ttl 秒，0 为不限制
      * @param mod 设置模式: 空,nx（key不存在才建立）,xx（key存在才修改）
-     * @param etc 配置项，主要用 etc.pre
      */
-    async set(key, val, ttl, mod, etc) {
-        this.refreshLast();
+    async set(key, val, ttl = 0, mod = '') {
         if (typeof val !== 'string') {
             val = lText.stringifyJson(val);
         }
         try {
             switch (mod) {
                 case '': {
-                    return await this._link.set(etc.pre + key, val, ttl === 0 ? undefined : ttl);
+                    return await this._link.set(this._pre + key, val, ttl === 0 ? undefined : ttl);
                 }
                 case 'nx': {
-                    return await this._link.setNX(etc.pre + key, val, ttl === 0 ? undefined : ttl);
+                    return await this._link.setNX(this._pre + key, val, ttl === 0 ? undefined : ttl);
                 }
                 case 'xx': {
-                    return await this._link.replace(etc.pre + key, val, ttl === 0 ? undefined : ttl);
+                    return await this._link.replace(this._pre + key, val, ttl === 0 ? undefined : ttl);
                 }
             }
         }
@@ -739,10 +98,9 @@ export class Connection {
      * @param key
      * @param val
      * @param ttl 秒，0 为不限制
-     * @param etc
      */
-    async add(key, val, ttl, etc) {
-        return this.set(key, val, ttl, 'nx', etc);
+    async add(key, val, ttl = 0) {
+        return this.set(key, val, ttl, 'nx');
     }
     /**
      * --- 替换一个存在的值 ---
@@ -751,19 +109,17 @@ export class Connection {
      * @param ttl 秒，0 为不限制
      * @param etc
      */
-    async replace(key, val, ttl, etc) {
-        return this.set(key, val, ttl, 'xx', etc);
+    async replace(key, val, ttl = 0) {
+        return this.set(key, val, ttl, 'xx');
     }
     /**
      * --- 向已存在的值后追加数据 ---
      * @param key
      * @param val
-     * @param etc
      */
-    async append(key, val, etc) {
-        this.refreshLast();
+    async append(key, val) {
         try {
-            return await this._link.append(etc.pre + key, val) > 0 ? true : false;
+            return await this._link.append(this._pre + key, val) > 0 ? true : false;
         }
         catch {
             return false;
@@ -774,8 +130,7 @@ export class Connection {
      * @param key
      * @param val
      */
-    async prepend(key, val, etc) {
-        this.refreshLast();
+    async prepend(key, val) {
         try {
             const script = `local val = redis.call('GET', KEYS[1])
 if (val == false) then
@@ -787,11 +142,11 @@ if (r) then
 else
     return 0
 end`;
-            let r = await this._link.evalSHA('ea360f3f6508a243824ecda6be15db56df217873', [etc.pre + key], [val]);
+            let r = await this._link.evalSHA('ea360f3f6508a243824ecda6be15db56df217873', [this._pre + key], [val]);
             r = parseInt(r);
             if (r <= 0) {
                 await this._link.scriptLoad(script);
-                r = this._link.evalSHA('ea360f3f6508a243824ecda6be15db56df217873', [etc.pre + key], [val]);
+                r = await this._link.evalSHA('ea360f3f6508a243824ecda6be15db56df217873', [this._pre + key], [val]);
                 r = parseInt(r);
             }
             return r > 0 ? true : false;
@@ -803,16 +158,14 @@ end`;
     /**
      * --- 检测 key 是否存在 ---
      * @param keys 单个或序列
-     * @param etc
      */
-    async exists(keys, etc) {
-        this.refreshLast();
+    async exists(keys) {
         try {
             if (typeof keys === 'string') {
                 keys = [keys];
             }
             for (let k = 0; k < keys.length; ++k) {
-                keys[k] = etc.pre + keys[k];
+                keys[k] = this._pre + keys[k];
             }
             return await this._link.mExists(keys);
         }
@@ -823,13 +176,11 @@ end`;
     /**
      * --- 获取字符串 ---
      * @param key
-     * @param etc
      * @returns 字符串 / false / null（即使存入时是 number，这个方法也只会返回字符串）
      */
-    async get(key, etc) {
-        this.refreshLast();
+    async get(key) {
         try {
-            return await this._link.get(etc.pre + key);
+            return await this._link.get(this._pre + key);
         }
         catch {
             return false;
@@ -838,12 +189,10 @@ end`;
     /**
      * --- 获取相应的剩余有效期秒数 ---
      * @param key
-     * @param etc
      */
-    async ttl(key, etc) {
-        this.refreshLast();
+    async ttl(key) {
         try {
-            return await this._link.ttl(etc.pre + key);
+            return await this._link.ttl(this._pre + key);
         }
         catch {
             return null;
@@ -852,12 +201,10 @@ end`;
     /**
      * --- 获取相应的剩余有效期毫秒数 ---
      * @param key
-     * @param etc
      */
-    async pttl(key, etc) {
-        this.refreshLast();
+    async pttl(key) {
         try {
-            return await this._link.pTTL(etc.pre + key);
+            return await this._link.pTTL(this._pre + key);
         }
         catch {
             return null;
@@ -866,16 +213,14 @@ end`;
     /**
      * --- 批量获取值 ---
      * @param keys key 序列
-     * @param etc 顺序数组
      */
-    async mGet(keys, etc) {
-        this.refreshLast();
+    async mGet(keys) {
         for (let k = 0; k < keys.length; ++k) {
-            keys[k] = etc.pre + keys[k];
+            keys[k] = this._pre + keys[k];
         }
         const rtn = {};
         try {
-            const pl = etc.pre.length;
+            const pl = this._pre.length;
             const r = await this._link.mGet(keys);
             if (pl === 0) {
                 return r;
@@ -897,12 +242,11 @@ end`;
      * @param rows key / val 数组
      * @param etc
      */
-    async mSet(rows, etc) {
-        this.refreshLast();
+    async mSet(rows) {
         try {
             const rtn = {};
             for (const key in rows) {
-                rtn[etc.pre + key] = rows[key];
+                rtn[this._pre + key] = rows[key];
             }
             await this._link.mSet(rtn);
             return true;
@@ -914,10 +258,9 @@ end`;
     /**
      * --- 获取 json 对象 ---
      * @param key
-     * @param etc
      */
-    async getJson(key, etc) {
-        const v = await this.get(key, etc);
+    async getJson(key) {
+        const v = await this.get(key);
         if (v === null || v === false) {
             return v;
         }
@@ -927,15 +270,13 @@ end`;
     /**
      * --- 删除已存在的值 ---
      * @param keys
-     * @param etc
      */
-    async del(keys, etc) {
-        this.refreshLast();
+    async del(keys) {
         if (typeof keys === 'string') {
             keys = [keys];
         }
         for (let k = 0; k < keys.length; ++k) {
-            keys[k] = etc.pre + keys[k];
+            keys[k] = this._pre + keys[k];
         }
         try {
             return await this._link.del(keys) > 0 ? true : false;
@@ -948,21 +289,19 @@ end`;
      * --- 自增 ---
      * @param key
      * @param num 整数或浮点正数
-     * @param etc
      */
-    async incr(key, num, etc) {
-        this.refreshLast();
+    async incr(key, num = 1) {
         try {
             if (Number.isInteger(num)) {
                 if (num === 1) {
-                    return await this._link.incr(etc.pre + key);
+                    return await this._link.incr(this._pre + key);
                 }
                 else {
-                    return await this._link.incr(etc.pre + key, num);
+                    return await this._link.incr(this._pre + key, num);
                 }
             }
             else {
-                return await this._link.incrByFloat(etc.pre + key, num);
+                return await this._link.incrByFloat(this._pre + key, num);
             }
         }
         catch {
@@ -973,21 +312,19 @@ end`;
      * --- 自减 ---
      * @param key
      * @param num 整数或浮点正数
-     * @param etc
      */
-    async decr(key, num, etc) {
-        this.refreshLast();
+    async decr(key, num = 1) {
         try {
             if (Number.isInteger(num)) {
                 if (num === 1) {
-                    return await this._link.decr(etc.pre + key);
+                    return await this._link.decr(this._pre + key);
                 }
                 else {
-                    return await this._link.decr(etc.pre + key, num);
+                    return await this._link.decr(this._pre + key, num);
                 }
             }
             else {
-                return await this._link.incrByFloat(etc.pre + key, -num);
+                return await this._link.incrByFloat(this._pre + key, -num);
             }
         }
         catch {
@@ -998,12 +335,10 @@ end`;
      * --- 仅修改过期时间不修改值 ---
      * @param key
      * @param ttl
-     * @param etc
      */
-    async expire(key, ttl, etc) {
-        this.refreshLast();
+    async expire(key, ttl) {
         try {
-            return await this._link.expire(etc.pre + key, ttl);
+            return await this._link.expire(this._pre + key, ttl);
         }
         catch {
             return false;
@@ -1013,11 +348,10 @@ end`;
      * --- 获取服务器上的所有 key 列表 ---
      * @param pattern
      */
-    async keys(pattern, etc) {
-        this.refreshLast();
+    async keys(pattern) {
         try {
-            const r = await this._link.keys(etc.pre + pattern);
-            const pl = etc.pre.length;
+            const r = await this._link.keys(this._pre + pattern);
+            const pl = this._pre.length;
             if (pl > 0) {
                 for (let k = 0; k < r.length; ++k) {
                     r[k] = r[k].slice(pl);
@@ -1034,14 +368,12 @@ end`;
      * @param cursor
      * @param pattern 例如 *
      * @param count 获取的条数
-     * @param etc
      */
-    async scan(cursor, pattern, count, etc) {
-        this.refreshLast();
+    async scan(cursor = 0, pattern = '*', count = 10) {
         try {
-            const r = await this._link.scan(cursor, etc.pre + pattern, count);
+            const r = await this._link.scan(cursor, this._pre + pattern, count);
             for (let i = 0; i < r.items.length; ++i) {
-                r.items[i] = r.items[i].slice(this._etc.pre.length);
+                r.items[i] = r.items[i].slice(this._pre.length);
             }
             return r;
         }
@@ -1053,7 +385,6 @@ end`;
      * --- 清除当前所选数据库的所有内容 ---
      */
     async flushDb() {
-        this.refreshLast();
         try {
             await this._link.flushDb();
             return true;
@@ -1066,10 +397,7 @@ end`;
      * --- 发送 ping ---
      * @param last 是否刷新最后使用时间（默认刷新）
      */
-    async ping(last = true) {
-        if (last) {
-            this.refreshLast();
-        }
+    async ping() {
         try {
             return (await this._link.ping()) === 'PONG' ? 'PONG' : false;
         }
@@ -1083,19 +411,17 @@ end`;
      * @param field 字段名
      * @param val 值
      * @param mod 空,nx(key不存在才建立)
-     * @param etc
      */
-    async hSet(key, field, val, mod, etc) {
-        this.refreshLast();
+    async hSet(key, field, val, mod = '') {
         try {
             if (typeof val !== 'string') {
                 val = lText.stringifyJson(val);
             }
             if (mod === 'nx') {
-                return await this._link.hSetNX(etc.pre + key, field, val);
+                return await this._link.hSetNX(this._pre + key, field, val);
             }
             else {
-                return await this._link.hSet(etc.pre + key, field, val);
+                return await this._link.hSet(this._pre + key, field, val);
             }
         }
         catch {
@@ -1106,10 +432,8 @@ end`;
      * --- 批量设置哈希值 ---
      * @param key key 名
      * @param rows key / val 数组
-     * @param etc
      */
-    async hMSet(key, rows, etc) {
-        this.refreshLast();
+    async hMSet(key, rows) {
         try {
             for (const i in rows) {
                 const val = rows[i];
@@ -1117,7 +441,7 @@ end`;
                     rows[i] = lText.stringifyJson(val);
                 }
             }
-            await this._link.hMSet(etc.pre + key, rows);
+            await this._link.hMSet(this._pre + key, rows);
             return true;
         }
         catch {
@@ -1128,12 +452,10 @@ end`;
      * --- 获取哈希值 ---
      * @param key
      * @param field
-     * @param etc
      */
-    async hGet(key, field, etc) {
-        this.refreshLast();
+    async hGet(key, field) {
         try {
-            return await this._link.hGet(etc.pre + key, field);
+            return await this._link.hGet(this._pre + key, field);
         }
         catch {
             return null;
@@ -1143,10 +465,9 @@ end`;
      * --- 获取哈希 json 对象 ---
      * @param key
      * @param field
-     * @param etc
      */
-    async hGetJson(key, field, etc) {
-        const v = await this.hGet(key, field, etc);
+    async hGetJson(key, field) {
+        const v = await this.hGet(key, field);
         if (v === null) {
             return null;
         }
@@ -1157,12 +478,10 @@ end`;
      * --- 批量获取哈希值 ---
      * @param key
      * @param fields
-     * @param etc
      */
-    async hMGet(key, fields, etc) {
-        this.refreshLast();
+    async hMGet(key, fields) {
         try {
-            return await this._link.hMGet(etc.pre + key, fields);
+            return await this._link.hMGet(this._pre + key, fields);
         }
         catch {
             const rtn = {};
@@ -1175,12 +494,10 @@ end`;
     /**
      * --- 批量获取哈希键值对 ---
      * @param key
-     * @param etc
      */
-    async hGetAll(key, etc) {
-        this.refreshLast();
+    async hGetAll(key) {
         try {
-            return await this._link.hGetAll(etc.pre + key);
+            return await this._link.hGetAll(this._pre + key);
         }
         catch {
             return null;
@@ -1190,12 +507,10 @@ end`;
      * --- 删除哈希键 ---
      * @param key
      * @param fields 值序列
-     * @param etc
      */
-    async hDel(key, fields, etc) {
-        this.refreshLast();
+    async hDel(key, fields) {
         try {
-            return await this._link.hDel(etc.pre + key, fields);
+            return await this._link.hDel(this._pre + key, fields);
         }
         catch {
             return 0;
@@ -1205,12 +520,10 @@ end`;
      * --- 判断哈希字段是否存在 ---
      * @param key
      * @param field
-     * @param etc
      */
-    async hExists(key, field, etc) {
-        this.refreshLast();
+    async hExists(key, field) {
         try {
-            return await this._link.hExists(etc.pre + key, field);
+            return await this._link.hExists(this._pre + key, field);
         }
         catch {
             return false;
@@ -1221,16 +534,14 @@ end`;
      * @param key key
      * @param field 字段
      * @param increment 正数或负数，整数或浮点
-     * @param etc
      */
-    async hIncr(key, field, increment, etc) {
-        this.refreshLast();
+    async hIncr(key, field, increment) {
         try {
             if (Number.isInteger(increment)) {
-                return await this._link.hIncr(etc.pre + key, field, increment);
+                return await this._link.hIncr(this._pre + key, field, increment);
             }
             else {
-                return await this._link.hIncrByFloat(etc.pre + key, field, increment);
+                return await this._link.hIncrByFloat(this._pre + key, field, increment);
             }
         }
         catch {
@@ -1240,87 +551,77 @@ end`;
     /**
      * --- 获取哈希所有字段 ---
      * @param key
-     * @param etc
      */
-    async hKeys(key, etc) {
-        this.refreshLast();
+    async hKeys(key) {
         try {
-            return await this._link.hKeys(etc.pre + key);
+            return await this._link.hKeys(this._pre + key);
         }
         catch {
             return [];
         }
     }
-    async lPush(key, values, etc) {
-        this.refreshLast();
+    async lPush(key, values) {
         try {
-            return await this._link.lPush(etc.pre + key, values);
+            return await this._link.lPush(this._pre + key, values);
         }
         catch {
             return 0;
         }
     }
-    async rPush(key, values, etc) {
-        this.refreshLast();
+    async rPush(key, values) {
         try {
-            return await this._link.rPush(etc.pre + key, values);
+            return await this._link.rPush(this._pre + key, values);
         }
         catch {
             return 0;
         }
     }
-    async bLMove(sourceKey, destKey, soo, deo, timeout, etc) {
-        this.refreshLast();
+    async bLMove(sourceKey, destKey, soo, deo, timeout) {
         try {
-            return await this._link.bLMove(etc.pre + sourceKey, etc.pre + destKey, soo, deo, timeout);
+            return await this._link.bLMove(this._pre + sourceKey, this._pre + destKey, soo, deo, timeout);
         }
         catch {
             return null;
         }
     }
-    async lPop(key, etc) {
-        this.refreshLast();
+    async lPop(key) {
         try {
-            return await this._link.lPop(etc.pre + key);
+            return await this._link.lPop(this._pre + key);
         }
         catch {
             return null;
         }
     }
-    async rPop(key, etc) {
-        this.refreshLast();
+    async rPop(key) {
         try {
-            return await this._link.rPop(etc.pre + key);
+            return await this._link.rPop(this._pre + key);
         }
         catch {
             return null;
         }
     }
-    async bRPop(key, timeout, etc) {
-        this.refreshLast();
+    async bRPop(key, timeout) {
         try {
             if (typeof key === 'string') {
                 key = [key];
             }
-            return await this._link.bRPop(key.map(item => etc.pre + item), timeout);
+            return await this._link.bRPop(key.map(item => this._pre + item), timeout);
         }
         catch {
             return {};
         }
     }
-    async lRange(key, start, stop, etc) {
-        this.refreshLast();
+    async lRange(key, start, stop) {
         try {
-            return await this._link.lRange(etc.pre + key, start, stop);
+            return await this._link.lRange(this._pre + key, start, stop);
         }
         catch {
             return [];
         }
     }
-    async lLen(key, etc) {
-        this.refreshLast();
+    async lLen(key) {
         try {
-            return await this._link.lLen(etc.pre + key);
+            return await this._link.lLen(this._pre + key);
         }
         catch {
             return 0;
@@ -1328,30 +629,12 @@ end`;
     }
 }
 /**
- * --- 获取 Kv Pool 对象 ---
+ * --- 获取 Kv 对象 ---
  * @param etc 配置信息可留空
  */
-export function get(ctr, etc) {
+export async function get(ctr, etc) {
     etc ??= ctr.getPrototype('_config').kv;
-    return new Pool(ctr, etc);
-}
-/**
- * --- 获取当前连接池中所有连接的信息 ---
- */
-export function getConnectionList() {
-    const list = [];
-    for (let i = 0; i < connections.length; ++i) {
-        const connection = connections[i];
-        const etc = connection.getEtc();
-        list.push({
-            'id': i,
-            'last': connection.getLast(),
-            'host': etc.host,
-            'port': etc.port,
-            'index': etc.index,
-            'lost': connection.isLost(),
-            'using': connection.isUsing()
-        });
-    }
-    return list;
+    const kv = new Kv(ctr, etc);
+    const r = await kv.init(ctr, etc);
+    return r ? kv : false;
 }