@pi-r/redis 0.10.3 → 0.11.1

package/LICENSE

@@ -1,4 +1,4 @@
-Copyright 2024 An Pham
+Copyright 2025 An Pham
 
 Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
 

package/client/index.js

@@ -1,58 +1,37 @@
-"use strict";
-exports.DB_SOURCE_TYPE = exports.DB_SOURCE_CLIENT = void 0;
-exports.setCredential = setCredential;
-exports.executeQuery = executeQuery;
-exports.executeBatchQuery = executeBatchQuery;
-exports.checkTimeout = checkTimeout;
+'use strict';
+
+var node_crypto = require('node:crypto');
+var types = require('@e-mc/types');
+var util = require('@e-mc/db/util');
+
 const redis = require("redis");
-const node_crypto_1 = require("node:crypto");
 const Db = require("@e-mc/db");
-const types_1 = require("@e-mc/types");
-const util_1 = require("@e-mc/db/util");
 const DbPool = require("@pi-r/redis/client/pool");
 const POOL_STATE = {};
-async function doScan(client, key, index, cursor = [0], iterations = [Infinity], options) {
-    if (!Array.isArray(cursor)) {
-        cursor = [cursor];
-    }
+async function doScan(client, key, index, cursor = [], iterations = [], options) {
+    const target = (Array.isArray(cursor) ? cursor : [cursor]).map(item => Buffer.isBuffer(item) ? item : item.toString());
     if (!Array.isArray(iterations)) {
         iterations = [iterations];
     }
-    let result = [], current = cursor[index] ?? 0, length = iterations[index] ?? Infinity;
+    let result = [], current = target[index] ?? '0', length = iterations[index] ?? Infinity;
     do {
         const item = await client.hScan(key, current, options);
-        result = result.concat(item.tuples);
+        result = result.concat(item.entries);
         current = item.cursor;
-    } while (current > 0 && --length > 0);
+    } while (+current > 0 && --length > 0);
     return result;
 }
-async function getClient(db, options, poolKey) {
-    const socket = options.socket ||= {};
-    if (!poolKey) {
-        socket.keepAlive = false;
-    }
-    else if (typeof socket.keepAlive !== 'number') {
-        socket.keepAlive = undefined;
-    }
-    const client = db.createClient(options);
-    if (poolKey) {
-        client.on('end', () => {
-            delete POOL_STATE[poolKey];
-        });
-    }
-    await client.connect();
-    return client;
-}
+const convertFloat = (value) => typeof value === 'number' || types.isString(value) && !isNaN(value = +value) ? value : undefined;
 async function setCredential(item) {
     const credential = this.getCredential(item);
     const options = item.options ||= {};
-    const client = (0, types_1.isPlainObject)(options.client) ? options.client : options.client = {};
+    const client = types.isPlainObject(options.client) ? options.client : options.client = {};
     let { uri, username, password, database = 0 } = item;
     if (database > 0) {
         client.database = database;
     }
     if (credential) {
-        const auth = (0, util_1.parseServerAuth)(credential, 6379);
+        const auth = util.parseServerAuth(credential, 6379);
         if (auth.database && (database = +auth.database) > 0) {
             client.database ||= database;
         }
@@ -64,7 +43,7 @@ async function setCredential(item) {
         delete item.credential;
     }
     if (!uri) {
-        throw (0, types_1.errorMessage)("redis", "Invalid credentials", 'url');
+        throw types.errorMessage("redis", "Invalid credentials", 'url');
     }
     if (client.socket?.tls) {
         this.readTLSConfig(client.socket);
@@ -83,8 +62,8 @@ async function setCredential(item) {
     let pool;
     username = undefined;
     password = undefined;
-    if ((0, types_1.isString)(usePool)) {
-        username = client.username || (0, util_1.parseConnectionString)(uri)?.username;
+    if (types.isString(usePool)) {
+        username = client.username || util.parseConnectionString(uri)?.username;
         if (username) {
             [password, pool] = DbPool.validateKey(POOL_STATE, username, usePool);
             if (pool) {
@@ -98,17 +77,17 @@ async function setCredential(item) {
         }
     }
     const config = this.getPoolConfig("redis", password);
-    const poolOptions = client.isolationPoolOptions ||= {};
+    const poolOptions = {};
     if (config) {
         const { min, max, timeout } = config;
         if (min >= 0) {
-            poolOptions.min ??= min;
+            poolOptions.minimum ??= min;
         }
         if (max > 0) {
-            poolOptions.max ??= max;
+            poolOptions.maximum ??= max;
         }
         if (timeout > 0) {
-            poolOptions.acquireTimeoutMillis ??= timeout;
+            poolOptions.acquireTimeout ??= timeout;
         }
     }
     const poolKey = DbPool.asString(client);
@@ -117,13 +96,16 @@ async function setCredential(item) {
         return;
     }
     try {
-        const instance = new DbPool(await getClient(redis, client, poolKey), poolKey, username && password ? { username, password } : undefined).add(item);
+        const clientPool = redis.createClientPool(client, poolOptions);
+        clientPool.on('end', () => {
+            delete POOL_STATE[poolKey];
+        });
+        const instance = new DbPool(clientPool, poolKey, username && password ? { username, password } : undefined).add(item);
         instance.parent = POOL_STATE;
         instance.success = 1;
     }
     catch {
         item.usePool = false;
-        delete client.isolationPoolOptions;
     }
 }
 async function executeQuery(item, options) {
@@ -135,7 +117,7 @@ async function executeBatchQuery(batch, options = '', outResult) {
         return [];
     }
     let parallel, checkObject, connectOnce, errorQuery, sessionKey, outCacheMiss;
-    if ((0, types_1.isPlainObject)(options)) {
+    if (types.isPlainObject(options)) {
         ({ parallel, checkObject, connectOnce, errorQuery, sessionKey, outCacheMiss } = options);
     }
     else {
@@ -157,25 +139,28 @@ async function executeBatchQuery(batch, options = '', outResult) {
     const caching = this.hasCache("redis", sessionKey);
     const tasks = new Array(length);
     const clients = [];
-    let redisClient, redisCredential, redisCache = 0, onceCredential = connectOnce ? batch[0].options?.client : undefined;
+    const pools = [];
+    let redisClient, redisPool, redisCredential, onceCredential = connectOnce ? batch[0].options?.client : undefined;
     const getConnection = async (item, credential) => {
+        if (redisPool) {
+            return redisPool;
+        }
         item.transactionState = 64;
         let client;
         if (item.usePool) {
             const pool = DbPool.findKey(POOL_STATE, item.usePool, DbPool.asString(credential), ...connectOnce ? [item, batch[0]] : [item]);
             if (pool) {
-                client = await pool.getConnection(credential);
+                pools.push(client = await pool.getConnection(credential));
+                if (connectOnce) {
+                    redisPool = client;
+                }
                 pool.connected = true;
             }
         }
         if (!client) {
-            if (connectOnce && parallel) {
-                const size = length - redisCache;
-                if (size > 1) {
-                    (credential.isolationPoolOptions ||= {}).max = size;
-                }
-            }
-            clients.push(client = await getClient(redis, credential));
+            client = redis.createClient(credential);
+            await client.connect();
+            clients.push(client);
         }
         if (connectOnce) {
             redisClient = client;
@@ -189,10 +174,9 @@ async function executeBatchQuery(batch, options = '', outResult) {
     }
     for (let i = 0; i < length; ++i) {
         const item = batch[i];
-        const { source, key, format = 'HASH', search, aggregate, options: clientOptions = {}, ignoreCache } = item;
+        const { source, key, format = 'HASH', search, aggregate, streams, options: clientOptions = {}, ignoreCache } = item;
         let credential = (redisCredential || onceCredential), error;
-        if (!credential && !(0, types_1.isPlainObject)(credential = clientOptions.client) && (error = (0, types_1.errorMessage)(source, "Invalid credentials")) || !((0, types_1.isString)(key) || (0, types_1.isArray)(key) || (0, types_1.isPlainObject)(search) && ((0, types_1.isPlainObject)(search.schema) || (0, types_1.isString)(search.query)) || (0, types_1.isPlainObject)(aggregate) && ((0, types_1.isPlainObject)(aggregate.schema) || (0, types_1.isString)(aggregate.query))) && (error = (0, types_1.errorMessage)(source, "Missing database query", item.uri))) {
-            ++redisCache;
+        if (!credential && !types.isPlainObject(credential = clientOptions.client) && (error = types.errorMessage(source, "Invalid credentials")) || !(types.isString(key) || types.isArray(key) || types.isPlainObject(search) && (types.isPlainObject(search.schema) || types.isString(search.query)) || types.isPlainObject(aggregate) && (types.isPlainObject(aggregate.schema) || types.isString(aggregate.query))) && (error = types.errorMessage(source, "Missing database query", item.uri))) {
             if (this.handleFail(error, item, { errorQuery })) {
                 if (!parallel) {
                     tasks.length = 0;
@@ -209,21 +193,20 @@ async function executeBatchQuery(batch, options = '', outResult) {
             continue;
         }
         item.transactionState = 1;
-        const command = (0, types_1.isPlainObject)(clientOptions.command) ? redis.commandOptions(clientOptions.command) : null;
         const uuidKey = credential.uuidKey ||= (onceCredential ? batch[0] : item).credential?.uuidKey;
-        const targetObject = typeof checkObject === 'string' ? this.hasCoerce("redis", 'options', uuidKey) && (0, types_1.asFunction)(checkObject) : checkObject;
+        const targetObject = typeof checkObject === 'string' ? this.hasCoerce("redis", 'options', uuidKey) && types.asFunction(checkObject) : checkObject;
         const cacheValue = ignoreCache === undefined ? sessionKey : Array.isArray(ignoreCache) ? { sessionKey, exclusiveOf: ignoreCache } : { sessionKey, renewCache: ignoreCache === 0 };
-        if (command) {
-            command.signal ||= this.signal;
-        }
         let queryString = '', rows;
         if (caching && ignoreCache !== true) {
-            if ((0, types_1.isObject)(search)) {
+            if (types.isObject(search)) {
                 queryString = Db.asString(search, true);
             }
-            else if ((0, types_1.isObject)(aggregate)) {
+            else if (types.isObject(aggregate)) {
                 queryString = Db.asString(aggregate, true);
             }
+            else if (streams) {
+                queryString = Db.asString(streams, true);
+            }
             else if (!targetObject) {
                 queryString = Db.asString(key, true);
             }
@@ -236,7 +219,6 @@ async function executeBatchQuery(batch, options = '', outResult) {
             if (ignoreCache !== 1) {
                 rows = this.getQueryResult(source, DbPool.sanitize(credential), queryString, cacheValue);
                 if (rows) {
-                    ++redisCache;
                     if (parallel) {
                         tasks[i] = Promise.resolve(rows);
                     }
@@ -264,7 +246,7 @@ async function executeBatchQuery(batch, options = '', outResult) {
         tasks[i] = new Promise(async (resolve, reject) => {
             let commandType;
             try {
-                const client = redisClient || await getConnection(item, credential);
+                let client = redisClient || await getConnection(item, credential);
                 const a = (arg) => typeof arg === 'string' || Buffer.isBuffer(arg) || typeof arg === 'number';
                 const b = (arg) => typeof arg === 'number' || Buffer.isBuffer(arg) ? arg.toString() : arg;
                 if (item.update) {
@@ -272,61 +254,72 @@ async function executeBatchQuery(batch, options = '', outResult) {
                     const values = (!Array.isArray(item.update) ? [item.update] : item.update).map(async (target) => {
                         return new Promise(async (success, failed) => {
                             let { key: k, value: v, format: f, NX, XX, options: setOptions = {} } = target;
-                            f = ((0, types_1.isString)(f) ? f.toUpperCase() : 'HASH');
+                            f = (types.isString(f) ? f.toUpperCase() : 'HASH');
                             if (v === undefined && f !== 'JSON') {
                                 success(target);
                                 return;
                             }
                             const has = (n) => typeof n === 'number' && n > 0;
-                            const failKey = () => {
-                                failed((0, types_1.errorMessage)(f, "Invalid key", Db.asString(k) || "Unknown"));
-                            };
-                            const failValue = () => {
-                                failed((0, types_1.errorMessage)(f, "Invalid value", Db.asString(v) || "Unknown"));
-                            };
-                            const commandSet = (0, types_1.isPlainObject)(setOptions.command) && redis.commandOptions(setOptions.command);
+                            const failKey = () => failed(types.errorMessage(f, "Invalid key", Db.asString(k) || "Unknown"));
+                            const failValue = () => failed(types.errorMessage(f, "Invalid value", Db.asString(v) || "Unknown"));
+                            if (types.isPlainObject(setOptions.command)) {
+                                client = client.withCommandOptions(setOptions.command);
+                            }
                             let pending, codeMin = 0, EX, PX, EXAT, PXAT, KEEPTTL;
                             if (f === 'JSON') {
                                 if (typeof k !== 'string') {
                                     failKey();
                                     return;
                                 }
-                                if (this.hasCoerce("redis", 'options', uuidKey) && (0, types_1.isString)(v) && v.startsWith('new')) {
-                                    ({ outV: v } = (0, types_1.coerceObject)({ outV: v }));
-                                }
-                                let { path = '$', command: cmd, start, stop, index } = target;
-                                const name = ((0, types_1.isString)(cmd) ? cmd.toUpperCase() : 'SET');
-                                if (Array.isArray(v) && name !== 'ARRAPPEND' && name !== 'ARRINSERT' && name !== 'MSET') {
-                                    v = v[0];
+                                if (this.hasCoerce("redis", 'options', uuidKey) && types.isString(v) && v.startsWith('new')) {
+                                    ({ outV: v } = types.coerceObject({ outV: v }));
                                 }
+                                const { path = '$', command: cmd, start, stop, index } = target;
+                                const name = (types.isString(cmd) ? cmd.toUpperCase() : 'SET');
                                 switch (name) {
                                     case 'ARRAPPEND':
-                                        pending = commandSet ? client.json.arrAppend(commandSet, k, path, ...(Array.isArray(v) ? v : [v])) : client.json.arrAppend(k, path, ...(Array.isArray(v) ? v : [v]));
+                                    case 'ARRINSERT': {
+                                        let v1, v2;
+                                        if (types.isArray(v)) {
+                                            v1 = v[0];
+                                            v2 = v.slice(1);
+                                        }
+                                        else {
+                                            v1 = v;
+                                            v2 = [];
+                                        }
+                                        if (name === 'ARRAPPEND') {
+                                            pending = client.json.arrAppend(k, path, v1, ...v2);
+                                        }
+                                        else if (typeof index === 'number') {
+                                            pending = client.json.arrInsert(k, path, index, v1, ...v2);
+                                        }
                                         break;
-                                    case 'ARRINDEX':
+                                    }
+                                    case 'ARRINDEX': {
+                                        const s1 = convertFloat(start);
                                         codeMin = -1;
-                                        pending = commandSet ? client.json.arrIndex(commandSet, k, path, v, start, stop) : client.json.arrIndex(k, path, v, start, stop);
-                                        break;
-                                    case 'ARRINSERT':
-                                        if (typeof index === 'number' || (0, types_1.isString)(index) && !isNaN(index = parseInt(index))) {
-                                            pending = commandSet ? client.json.arrInsert(commandSet, k, path, index, ...(Array.isArray(v) ? v : [v])) : client.json.arrInsert(k, path, index, ...(Array.isArray(v) ? v : [v]));
-                                        }
+                                        pending = client.json.arrIndex(k, path, v, s1 !== undefined ? { range: { start: s1, stop: convertFloat(stop) } } : undefined);
                                         break;
+                                    }
                                     case 'ARRPOP':
                                         codeMin = -Infinity;
-                                        pending = commandSet ? client.json.arrPop(commandSet, k, path, index) : client.json.arrPop(k, path, index);
+                                        pending = client.json.arrPop(k, { path, index: convertFloat(index) });
                                         break;
-                                    case 'ARRTRIM':
-                                        if ((typeof start === 'number' || (0, types_1.isString)(start) && !isNaN(start = parseInt(start))) && (typeof stop === 'number' || (0, types_1.isString)(stop) && !isNaN(stop = parseInt(stop)))) {
-                                            pending = commandSet ? client.json.arrTrim(commandSet, k, path, start, stop) : client.json.arrTrim(k, path, start, stop);
+                                    case 'ARRTRIM': {
+                                        const s1 = convertFloat(start);
+                                        const s2 = convertFloat(stop);
+                                        if (s1 !== undefined && s2 !== undefined) {
+                                            pending = client.json.arrTrim(k, path, s1, s2);
                                         }
                                         break;
+                                    }
                                     case 'DEL':
                                     case 'FORGET':
-                                        pending = commandSet ? client.json[name === 'DEL' ? 'del' : 'forget'](commandSet, k, path) : client.json[name === 'DEL' ? 'del' : 'forget'](k, path);
+                                        pending = client.json[name === 'DEL' ? 'del' : 'forget'](k, { path });
                                         break;
                                     case 'MERGE':
-                                        pending = commandSet ? client.json.merge(commandSet, k, path, v) : client.json.merge(k, path, v);
+                                        pending = client.json.merge(k, path, v);
                                         break;
                                     case 'MSET': {
                                         const data = (Array.isArray(v) ? v : [v])
@@ -337,24 +330,26 @@ async function executeBatchQuery(batch, options = '', outResult) {
                                             return m;
                                         });
                                         if (data.length > 0) {
-                                            pending = commandSet ? client.json.mSet(commandSet, data) : client.json.mSet(data);
+                                            pending = client.json.mSet(data);
                                         }
                                         break;
                                     }
                                     case 'NUMINCRBY':
-                                    case 'NUMMULTBY':
-                                        if (typeof v === 'number' || (0, types_1.isString)(v) && !isNaN(v = parseFloat(v))) {
-                                            pending = commandSet ? client.json[name === 'NUMINCRBY' ? 'numIncrBy' : 'numMultBy'](commandSet, k, path, v) : client.json[name === 'NUMINCRBY' ? 'numIncrBy' : 'numMultBy'](k, path, v);
+                                    case 'NUMMULTBY': {
+                                        const n = convertFloat(v);
+                                        if (n !== undefined) {
+                                            pending = client.json[name === 'NUMINCRBY' ? 'numIncrBy' : 'numMultBy'](k, path, n);
                                         }
                                         break;
+                                    }
                                     case 'STRAPPEND':
-                                        if ((0, types_1.isString)(v)) {
-                                            pending = commandSet ? client.json.strAppend(commandSet, k, path, v) : client.json.strAppend(k, path, v);
+                                        if (types.isString(v)) {
+                                            pending = client.json.strAppend(k, v, { path });
                                         }
                                         break;
                                     default: {
                                         const flags = NX ? { NX } : XX ? { XX } : undefined;
-                                        pending = commandSet ? client.json.set(commandSet, k, path, v, flags) : client.json.set(k, path, v, flags);
+                                        pending = client.json.set(k, path, v, flags);
                                         break;
                                     }
                                 }
@@ -362,39 +357,39 @@ async function executeBatchQuery(batch, options = '', outResult) {
                             else if (typeof k === 'string' || Buffer.isBuffer(k)) {
                                 ({ EX, PX, EXAT, PXAT, KEEPTTL } = target);
                                 const field = target.field;
-                                if (field === undefined && field === null) {
+                                if (field == null) {
                                     if (a(v)) {
                                         const flags = setOptions.set || {};
                                         if (NX) {
-                                            flags.NX = true;
+                                            flags.condition = 'NX';
                                         }
                                         if (XX) {
-                                            flags.XX = true;
+                                            flags.condition = 'XX';
                                         }
                                         if (has(EX)) {
-                                            flags.EX = EX;
+                                            flags.expiration = { type: 'EX', value: EX };
                                             EX = 0;
                                         }
                                         if (has(PX)) {
-                                            flags.PX = PX;
+                                            flags.expiration = { type: 'PX', value: PX };
                                             PX = 0;
                                         }
                                         if (has(EXAT)) {
-                                            flags.EXAT = EXAT;
+                                            flags.expiration = { type: 'EXAT', value: EXAT };
                                             EXAT = 0;
                                         }
                                         if (has(PXAT)) {
-                                            flags.PXAT = PXAT;
+                                            flags.expiration = { type: 'PXAT', value: PXAT };
                                             PXAT = 0;
                                         }
                                         if (KEEPTTL) {
-                                            flags.KEEPTTL = true;
+                                            flags.expiration = { type: 'KEEPTTL' };
                                             KEEPTTL = false;
                                         }
                                         codeMin = NaN;
-                                        pending = commandSet ? client.set(commandSet, k, v, flags) : client.set(k, v, flags);
+                                        pending = client.set(k, v, flags);
                                     }
-                                    else if ((0, types_1.isObject)(v)) {
+                                    else if (types.isObject(v)) {
                                         let valid = true;
                                         if (NX || XX) {
                                             valid = await client.exists(k) === 1;
@@ -406,26 +401,26 @@ async function executeBatchQuery(batch, options = '', outResult) {
                                             success(target);
                                             return;
                                         }
-                                        pending = commandSet ? client.hSet(commandSet, k, v) : client.hSet(k, v);
+                                        pending = client.hSet(k, v);
                                     }
                                 }
                                 else if (NX) {
                                     if (a(field) && a(v)) {
                                         codeMin = -1;
-                                        pending = commandSet ? client.hSetNX(commandSet, k, b(field), b(v)) : client.hSetNX(k, b(field), b(v));
+                                        pending = client.hSetNX(k, b(field), b(v));
                                     }
                                 }
                                 else {
-                                    let valid = true;
-                                    if (XX) {
-                                        valid = a(k) && a(field) && await client.hExists(b(k), b(field));
+                                    let valid = 1;
+                                    if (XX && a(k) && a(field)) {
+                                        valid = await client.hExists(b(k), b(field));
                                     }
                                     if (a(field) && a(v)) {
-                                        if (!valid) {
+                                        if (valid === 0) {
                                             success(target);
                                             return;
                                         }
-                                        pending = commandSet ? client.hSet(commandSet, k, field, v) : client.hSet(k, field, v);
+                                        pending = client.hSet(k, field, v);
                                     }
                                 }
                             }
@@ -435,7 +430,7 @@ async function executeBatchQuery(batch, options = '', outResult) {
                             }
                             if (pending) {
                                 pending.then(async (code) => {
-                                    if (code === undefined || code === null || code !== -Infinity && (0, types_1.isString)(code) && code !== 'OK' || typeof code === 'number' && code <= codeMin || Array.isArray(code) && code.every(resp => resp === null || typeof resp === 'number' && resp <= codeMin)) {
+                                    if (code == null || code !== -Infinity && types.isString(code) && code !== 'OK' || typeof code === 'number' && code <= codeMin || Array.isArray(code) && code.every(resp => resp === null || typeof resp === 'number' && resp <= codeMin)) {
                                         failValue();
                                         return;
                                     }
@@ -473,7 +468,7 @@ async function executeBatchQuery(batch, options = '', outResult) {
                                                 success(target);
                                             }
                                             else {
-                                                failed((0, types_1.errorMessage)(f, "Invalid value", has(EX) ? 'EX: ' + EX : has(PX) ? 'PX: ' + PX : has(EXAT) ? 'EXAT: ' + EX : 'PXAT: ' + PXAT));
+                                                failed(types.errorMessage(f, "Invalid value", has(EX) ? 'EX: ' + EX : has(PX) ? 'PX: ' + PX : has(EXAT) ? 'EXAT: ' + EX : 'PXAT: ' + PXAT));
                                             }
                                         })
                                             .catch(failed);
@@ -504,26 +499,31 @@ async function executeBatchQuery(batch, options = '', outResult) {
                         }
                     });
                 }
+                const commandOptions = credential.commandOptions || clientOptions.command;
+                if (types.isPlainObject(commandOptions)) {
+                    commandOptions.abortSignal ||= this.signal;
+                    client = client.withCommandOptions(commandOptions);
+                }
                 commandType = this.commandType.SELECT;
-                const target = (0, types_1.isObject)(search) ? search : (0, types_1.isObject)(aggregate) ? aggregate : null;
+                const target = types.isObject(search) ? search : types.isObject(aggregate) ? aggregate : null;
                 if (target) {
                     const { query = '', schema, index } = target;
                     let idx = '';
-                    if ((0, types_1.isObject)(schema)) {
-                        idx = index || (0, node_crypto_1.randomUUID)();
-                        await (command ? client.ft.create(command, idx, schema, target.options) : client.ft.create(idx, schema, target.options));
+                    if (types.isObject(schema)) {
+                        idx = index || node_crypto.randomUUID();
+                        await client.ft.create(idx, schema, target.options);
                     }
                     try {
                         if (target === search) {
-                            const reply = await (command ? client.ft.search(command, index || idx, query, clientOptions.search) : client.ft.search(index || idx, query, clientOptions.search));
+                            const reply = await client.ft.search(index || idx, query, clientOptions.search);
                             rows = reply.documents.map(doc => (doc.value.__id__ = doc.id) && doc.value);
                         }
                         else {
-                            ({ results: rows } = await (command ? client.ft.aggregate(command, index || idx, query, clientOptions.aggregate) : client.ft.aggregate(index || idx, query, clientOptions.aggregate)));
+                            ({ results: rows } = await client.ft.aggregate(index || idx, query, clientOptions.aggregate));
                         }
                     }
                     catch (err) {
-                        this.addLog(this.statusType.WARN, err, { source: target === search ? 'FT.SEARCH' : 'FT.AGGREGATE' });
+                        this.addLog(3, err, { source: target === search ? 'FT.SEARCH' : 'FT.AGGREGATE' });
                         if (err instanceof Error) {
                             throw err;
                         }
@@ -536,58 +536,70 @@ async function executeBatchQuery(batch, options = '', outResult) {
                         }
                     }
                 }
+                else if (streams) {
+                    const data = await client.xRead(streams, clientOptions.xread);
+                    if (data) {
+                        rows = data;
+                    }
+                }
                 else if (key) {
                     let data;
                     if (Array.isArray(key)) {
                         switch (format.toUpperCase()) {
                             case 'HKEYS':
-                                data = await Promise.all(key.map(async (k) => client.hKeys(...command ? [command, k] : [k])));
+                                data = await Promise.all(key.map(async (k) => client.hKeys(k)));
                                 break;
                             case 'HVALS':
-                                data = await Promise.all(key.map(async (k) => client.hVals(...command ? [command, k] : [k])));
+                                data = await Promise.all(key.map(async (k) => client.hVals(k)));
                                 break;
                             case 'HSCAN':
                                 data = await Promise.all(key.map(async (k, index) => doScan(client, k, index, item.cursor, item.iterations, clientOptions.scan)));
                                 break;
+                            case 'SMEMBERS':
+                                data = await Promise.all(key.map(async (k) => client.sMembers(k)));
+                                break;
                             case 'JSON':
-                                data = (await (command ? client.json.mGet(command, key.map(c => b(c)), item.path || '$') : client.json.mGet(key.map(c => b(c)), item.path || '$'))).flat();
+                                data = (await client.json.mGet(key.map(c => b(c)), item.path || '$')).flat();
                                 break;
                             default:
-                                data = await client.mGet(...command ? [command, key] : [key]);
+                                data = await client.mGet(key);
                                 break;
                         }
                     }
                     else {
                         switch (format.toUpperCase()) {
                             case 'HKEYS':
-                                data = await client.hKeys(...command ? [command, key] : [key]);
+                                data = await client.hKeys(key);
                                 break;
                             case 'HVALS':
-                                data = await client.hVals(...command ? [command, key] : [key]);
+                                data = await client.hVals(key);
                                 break;
                             case 'HSCAN':
                                 data = await doScan(client, key, 0, item.cursor, item.iterations, clientOptions.scan);
                                 break;
+                            case 'SMEMBERS':
+                                data = await client.sMembers(key);
+                                break;
                             case 'JSON':
-                                data = await (clientOptions.get ? client.json.get(...command ? [command, b(key), clientOptions.get] : [b(key), clientOptions.get]) : client.json.get(...command ? [command, b(key)] : [b(key)]));
+                                data = await client.json.get(b(key), clientOptions.get);
                                 break;
                             default:
                                 if (Array.isArray(item.field)) {
-                                    data = await client.hmGet(...command ? [command, key, item.field] : [key, item.field]);
+                                    data = await client.hmGet(key, item.field);
                                 }
                                 else if (item.field) {
-                                    data = await client.hGet(...command ? [command, key, item.field] : [key, item.field]);
+                                    data = await client.hGet(key, item.field);
                                 }
                                 else {
-                                    data = await client.hGetAll(...command ? [command, key] : [key]);
+                                    data = await client.hGetAll(key);
                                 }
                                 break;
                         }
                     }
                     rows = (targetObject ? targetObject(item, data) : data);
                 }
-                if (rows === undefined) {
-                    throw (0, types_1.errorMessage)(source, "Missing database query");
+                if (rows == null) {
+                    throw types.errorMessage(source, "Missing database query");
                 }
                 this.add(item, 4);
                 resolve(this.setQueryResult(source, DbPool.sanitize(redisCredential || credential), queryString, rows, cacheValue));
@@ -623,11 +635,14 @@ async function executeBatchQuery(batch, options = '', outResult) {
             }
         }
     }
-    return this.processRows(batch, tasks, clients.length === 0 ? parallel : {
+    return this.processRows(batch, tasks, {
         parallel,
         disconnect() {
             for (const item of clients) {
-                void item.disconnect();
+                item.destroy();
+            }
+            for (const item of pools) {
+                void item.close();
             }
         }
     }, outResult);
@@ -635,5 +650,12 @@ async function executeBatchQuery(batch, options = '', outResult) {
 async function checkTimeout(value, limit = 0) {
     return DbPool.checkTimeout(POOL_STATE, value, limit);
 }
-exports.DB_SOURCE_CLIENT = true;
-exports.DB_SOURCE_TYPE = types_1.DB_TYPE.NOSQL | types_1.DB_TYPE.KEYVALUE;
+const DB_SOURCE_CLIENT = true;
+const DB_SOURCE_TYPE = types.DB_TYPE.NOSQL | types.DB_TYPE.KEYVALUE;
+
+exports.DB_SOURCE_CLIENT = DB_SOURCE_CLIENT;
+exports.DB_SOURCE_TYPE = DB_SOURCE_TYPE;
+exports.checkTimeout = checkTimeout;
+exports.executeBatchQuery = executeBatchQuery;
+exports.executeQuery = executeQuery;
+exports.setCredential = setCredential;

package/client/pool.d.ts

@@ -1,9 +1,7 @@
 import type { DbPoolConstructor } from '@e-mc/types/lib/db';
 
-import type { DbPoolCredential, RedisDataSource } from '../types';
+import type { DbPoolCredential, RedisClientPoolInstance, RedisClientPoolType, RedisDataSource } from '../types';
 
-import type { RedisClientType } from 'redis';
-
-declare const RedisPool: DbPoolConstructor<RedisDataSource, RedisClientType, RedisClientType, DbPoolCredential>;
+declare const RedisPool: DbPoolConstructor<RedisDataSource, RedisClientPoolInstance, RedisClientPoolType, DbPoolCredential>;
 
 export = RedisPool;

package/client/pool.js

@@ -1,8 +1,7 @@
-"use strict";
 const DbPool = require('@e-mc/db/pool');
 const POOL_ACTIVE = new WeakSet();
 class RedisPool extends DbPool {
-    static CACHE_IGNORE = ['modules', 'functions', 'scripts'];
+    static CACHE_IGNORE = ['modules', 'functions', 'scripts', 'credentialsProvider'];
     static asString(credential) {
         if (credential.url) {
             return JSON.stringify(credential);
@@ -16,8 +15,8 @@ class RedisPool extends DbPool {
         if (!POOL_ACTIVE.has(credential) || credential.uuidKey) {
             return credential;
         }
-        if ('socket' in credential || 'isolationPoolOptions' in credential) {
-            return { ...credential, socket: credential.socket?.tls ? { tls: true } : undefined, isolationPoolOptions: undefined };
+        if ('socket' in credential) {
+            return { ...credential, socket: credential.socket?.tls ? { tls: true } : undefined };
         }
         return credential;
     }
@@ -25,13 +24,13 @@ class RedisPool extends DbPool {
         if (credential) {
             POOL_ACTIVE.add(credential);
         }
-        return this.client;
+        return this.client.connect();
     }
     async close() {
-        return this.client.disconnect();
+        return this.client.close();
     }
     isEmpty() {
-        return this.closed;
+        return this.closed || this.client.totalClients === 0;
     }
     get closed() {
         return !this.client.isOpen;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-r/redis",
-  "version": "0.10.3",
+  "version": "0.11.1",
   "description": "Redis client driver for E-mc.",
   "main": "client/index.js",
   "types": "client/index.d.ts",
@@ -9,7 +9,7 @@
   },
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/anpham6/pi-r.git",
+    "url": "git+https://github.com/anpham6/pi-r2.git",
     "directory": "src/db/redis"
   },
   "keywords": [
@@ -20,8 +20,8 @@
   "license": "MIT",
   "homepage": "https://github.com/anpham6/pi-r#readme",
   "dependencies": {
-    "@e-mc/db": "^0.12.7",
-    "@e-mc/types": "^0.12.7",
-    "redis": "^4.7.1"
+    "@e-mc/db": "^0.13.5",
+    "@e-mc/types": "^0.13.5",
+    "redis": "^5.10.0"
   }
 }

package/types/index.d.ts

@@ -4,31 +4,37 @@ import type { IdentifierAction } from '@e-mc/types/lib/core';
 import type { CascadeAction, ServerAuth } from '@e-mc/types/lib/db';
 import type { AuthValue } from '@e-mc/types/lib/http';
 
-import type { RedisJSON } from '@redis/json/dist/commands';
-import type { ClientCommandOptions } from '@redis/client/dist/lib/client';
-import type { RedisCommandArgument } from '@redis/client/dist/lib/commands';
-import type { CommandOptions } from '@redis/client/dist/lib/command-options';
-import type { AggregateOptions } from '@redis/search/dist/commands/AGGREGATE';
-import type { HScanTuple } from '@redis/client/dist/lib/commands/HSCAN';
-import type { ScanOptions } from '@redis/client/dist/lib/commands/generic-transformers';
-import type { RediSearchSchema, RedisClientOptions, SearchOptions, SetOptions } from 'redis';
+import type { RedisClientOptions } from '@redis/client';
+import type { RedisJSON } from '@redis/json/dist/lib/commands';
+import type { RedisArgument } from '@redis/client/dist/lib/RESP/types';
+import type { CommandOptions } from '@redis/client/dist/lib/client/commands-queue';
+import type { ScanOptions } from '@redis/client/dist/lib/commands/SCAN';
+import type { CreateOptions } from '@redis/search/dist/lib/commands/CREATE';
+import type { FtAggregateOptions } from '@redis/search/dist/lib/commands/AGGREGATE';
+import type { FtSearchOptions } from '@redis/search/dist/lib/commands/SEARCH';
+import type { JsonGetOptions } from '@redis/json/dist/lib/commands/GET';
+import type { XReadOptions, XReadStreams } from '@redis/client/dist/lib/commands/XREAD';
+import type { RedisClientPoolType as IRedisClientPoolType, RediSearchSchema, RedisDefaultModules, RedisModules, SetOptions } from 'redis';
 
 export interface RedisDataSource extends DbDataSource<string, PlainObject, RedisSetValue | RedisSetValue[] | RedisJSONValue | RedisJSONValue[], RedisCredential, string>, CascadeAction, AuthValue {
     source: "redis";
-    key?: RedisCommandArgument | RedisCommandArgument[];
-    field?: RedisCommandArgument | string[];
+    key?: RedisArgument | RedisArgument[];
+    field?: RedisArgument | string[];
     path?: string;
-    format?: RedisFormat | "HKEYS" | "HVALS" | "HSCAN";
+    format?: RedisFormat | "HKEYS" | "HVALS" | "HSCAN" | "SMEMBERS";
     search?: RedisQuery;
     aggregate?: RedisQuery;
-    cursor?: number | number[];
+    streams?: XReadStreams;
+    cursor?: RedisArgument | RedisArgument[] | number | number[];
     iterations?: number | number[];
     options?: {
         client?: RedisClientOptions;
-        command?: RedisCommandOptions;
-        get?: PlainObject;
-        search?: SearchOptions;
-        aggregate?: AggregateOptions;
+        /** @deprecated client.commandOptions */
+        command?: CommandOptions;
+        get?: JsonGetOptions;
+        search?: FtSearchOptions;
+        aggregate?: FtAggregateOptions;
+        xread?: XReadOptions;
         scan?: ScanOptions;
     };
     database?: number;
@@ -46,11 +52,11 @@ export interface RedisCommand<T = "HASH" | "JSON" | undefined, U = unknown, V =
     options?: {
         set?: SetOptions;
         expire?: { [K in RedisExpireCondition]?: boolean; };
-        command?: RedisCommandOptions;
+        command?: CommandOptions;
     };
 }
 
-export interface RedisSetValue extends RedisCommand<"HASH", RedisCommandArgument, RedisCommandValue | RedisHSETObject> {
+export interface RedisSetValue extends RedisCommand<"HASH", RedisArgument, RedisCommandValue | RedisHSETObject> {
     field?: RedisCommandValue | RedisHSETObject;
     EX?: number;
     PX?: number;
@@ -67,25 +73,26 @@ export interface RedisJSONValue extends RedisCommand<"JSON", string, RedisJSON |
     index?: number | string;
 }
 
-export interface RedisQuery {
+export interface RedisQuery<T = CreateOptions> {
     index?: string;
     schema?: RediSearchSchema | string;
     query?: string;
-    options?: PlainObject;
+    options?: T;
 }
 
 export interface JsonMSetItem {
-    key: RedisCommandArgument;
-    path: RedisCommandArgument;
+    key: RedisArgument;
+    path: RedisArgument;
     value: RedisJSON;
 }
 
 export type RedisFormat = "HASH" | "JSON";
 export type RedisCommandJSON = "ARRAPPEND" | "ARRINDEX" | "ARRINSERT" | "ARRPOP" | "ARRTRIM" | "DEL" | "FORGET" | "MERGE" | "MSET" | "NUMINCRBY" | "NUMMULTBY" | "SET" | "STRAPPEND";
 export type RedisExpireCondition = "NX" | "XX" | "GT" | "LT";
-export type RedisCommandValue = RedisCommandArgument | number;
-export type RedisCommandOptions = CommandOptions<ClientCommandOptions>;
+export type RedisCommandValue = RedisArgument | number;
+export type RedisClientPoolType<T extends RedisModules = RedisDefaultModules> = IRedisClientPoolType<T>;
+export type RedisClientPoolInstance = IRedisClientPoolType<any, any, any, any, any>; // eslint-disable-line @typescript-eslint/no-explicit-any
 export type RedisHSETObject = Record<number | string, RedisCommandValue>;
 export type DbPoolCredential = RedisClientOptions & IdentifierAction;
 
-export type { HScanTuple, RedisCommandArgument, RedisJSON, ScanOptions };
+export type { CommandOptions, RedisArgument, RedisJSON, ScanOptions };