@pi-r/redis 0.11.3 → 0.12.0

package/client/index.js

@@ -1,12 +1,11 @@
-'use strict';
+"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 Db = require("@e-mc/db");
-const DbPool = require("@pi-r/redis/client/pool");
+const redis = require('redis');
+const { randomUUID } = require('node:crypto');
+const Db = require('@e-mc/db');
+const { DB_TYPE, asFunction, coerceObject, errorMessage, isArray, isError, isObject, isPlainObject, isString } = require('@e-mc/types');
+const { parseConnectionString, parseServerAuth } = require('@e-mc/db/util');
+const DbPool = require('@pi-r/redis/client/pool');
 const POOL_STATE = {};
 async function doScan(client, key, index, cursor = [], iterations = [], options) {
     const target = (Array.isArray(cursor) ? cursor : [cursor]).map(item => Buffer.isBuffer(item) ? item : item.toString());
@@ -21,17 +20,17 @@ async function doScan(client, key, index, cursor = [], iterations = [], options)
     } while (+current > 0 && --length > 0);
     return result;
 }
-const convertFloat = (value) => typeof value === 'number' || types.isString(value) && !isNaN(value = +value) ? value : undefined;
+const convertFloat = (value) => typeof value === 'number' || isString(value) && !isNaN(value = +value) ? value : undefined;
 async function setCredential(item) {
     const credential = this.getCredential(item);
     const options = item.options ||= {};
-    const client = types.isPlainObject(options.client) ? options.client : options.client = {};
+    const client = isPlainObject(options.client) ? options.client : options.client = {};
     let { uri, username, password, database = 0 } = item;
     if (database > 0) {
         client.database = database;
     }
     if (credential) {
-        const auth = util.parseServerAuth(credential, 6379);
+        const auth = parseServerAuth(credential, 6379);
         if (auth.database && (database = +auth.database) > 0) {
             client.database ||= database;
         }
@@ -43,7 +42,7 @@ async function setCredential(item) {
         delete item.credential;
     }
     if (!uri) {
-        throw types.errorMessage("redis", "Invalid credentials", 'url');
+        throw errorMessage("redis", "Invalid credentials", 'url');
     }
     if (client.socket?.tls) {
         this.readTLSConfig(client.socket);
@@ -62,8 +61,8 @@ async function setCredential(item) {
     let pool;
     username = undefined;
     password = undefined;
-    if (types.isString(usePool)) {
-        username = client.username || util.parseConnectionString(uri)?.username;
+    if (isString(usePool)) {
+        username = client.username || parseConnectionString(uri)?.username;
         if (username) {
             [password, pool] = DbPool.validateKey(POOL_STATE, username, usePool);
             if (pool) {
@@ -79,13 +78,16 @@ async function setCredential(item) {
     const config = this.getPoolConfig("redis", password);
     const poolOptions = {};
     if (config) {
-        const { min, max, timeout } = config;
+        const { min, max, idle, timeout } = config;
         if (min >= 0) {
             poolOptions.minimum ??= min;
         }
         if (max > 0) {
             poolOptions.maximum ??= max;
         }
+        if (idle > 0) {
+            poolOptions.cleanupDelay ??= idle;
+        }
         if (timeout > 0) {
             poolOptions.acquireTimeout ??= timeout;
         }
@@ -117,7 +119,7 @@ async function executeBatchQuery(batch, options = '', outResult) {
         return [];
     }
     let parallel, checkObject, connectOnce, errorQuery, sessionKey, outCacheMiss;
-    if (types.isPlainObject(options)) {
+    if (isPlainObject(options)) {
         ({ parallel, checkObject, connectOnce, errorQuery, sessionKey, outCacheMiss } = options);
     }
     else {
@@ -175,8 +177,8 @@ async function executeBatchQuery(batch, options = '', outResult) {
     for (let i = 0; i < length; ++i) {
         const item = batch[i];
         const { source, key, format = 'HASH', search, aggregate, streams, options: clientOptions = {}, ignoreCache } = item;
-        let credential = (redisCredential || onceCredential), error;
-        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))) {
+        let credential = redisCredential || onceCredential, error;
+        if (!credential && !isPlainObject(credential = clientOptions.client) && (error = errorMessage(source, "Invalid credentials")) || !(isString(key) || isArray(key) || isPlainObject(search) && (isPlainObject(search.schema) || isString(search.query)) || isPlainObject(aggregate) && (isPlainObject(aggregate.schema) || isString(aggregate.query))) && (error = errorMessage(source, "Missing database query", item.uri))) {
             if (this.handleFail(error, item, { errorQuery })) {
                 if (!parallel) {
                     tasks.length = 0;
@@ -194,14 +196,14 @@ async function executeBatchQuery(batch, options = '', outResult) {
         }
         item.transactionState = 1;
         const uuidKey = credential.uuidKey ||= (onceCredential ? batch[0] : item).credential?.uuidKey;
-        const targetObject = typeof checkObject === 'string' ? this.hasCoerce("redis", 'options', uuidKey) && types.asFunction(checkObject) : checkObject;
+        const targetObject = typeof checkObject === 'string' ? this.hasCoerce("redis", 'options', uuidKey) ? asFunction(checkObject) : null : checkObject;
         const cacheValue = ignoreCache === undefined ? sessionKey : Array.isArray(ignoreCache) ? { sessionKey, exclusiveOf: ignoreCache } : { sessionKey, renewCache: ignoreCache === 0 };
         let queryString = '', rows;
         if (caching && ignoreCache !== true) {
-            if (types.isObject(search)) {
+            if (isObject(search)) {
                 queryString = Db.asString(search, true);
             }
-            else if (types.isObject(aggregate)) {
+            else if (isObject(aggregate)) {
                 queryString = Db.asString(aggregate, true);
             }
             else if (streams) {
@@ -251,18 +253,18 @@ async function executeBatchQuery(batch, options = '', outResult) {
                 const b = (arg) => typeof arg === 'number' || Buffer.isBuffer(arg) ? arg.toString() : arg;
                 if (item.update) {
                     commandType = this.commandType.UPDATE;
-                    const values = (!Array.isArray(item.update) ? [item.update] : item.update).map(async (target) => {
+                    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 = (types.isString(f) ? f.toUpperCase() : 'HASH');
+                            f = (isString(f) ? f.toUpperCase() : 'HASH');
                             if (v === undefined && f !== 'JSON') {
                                 success(target);
                                 return;
                             }
                             const has = (n) => typeof n === 'number' && n > 0;
-                            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)) {
+                            const failKey = () => failed(errorMessage(f, "Invalid key", Db.asString(k) || "Unknown"));
+                            const failValue = () => failed(errorMessage(f, "Invalid value", Db.asString(v) || "Unknown"));
+                            if (isPlainObject(setOptions.command)) {
                                 client = client.withCommandOptions(setOptions.command);
                             }
                             let pending, codeMin = 0, EX, PX, EXAT, PXAT, KEEPTTL;
@@ -271,16 +273,16 @@ async function executeBatchQuery(batch, options = '', outResult) {
                                     failKey();
                                     return;
                                 }
-                                if (this.hasCoerce("redis", 'options', uuidKey) && types.isString(v) && v.startsWith('new')) {
-                                    ({ outV: v } = types.coerceObject({ outV: v }));
+                                if (this.hasCoerce("redis", 'options', uuidKey) && isString(v) && v.startsWith('new')) {
+                                    ({ outV: v } = coerceObject({ outV: v }));
                                 }
                                 const { path = '$', command: cmd, start, stop, index } = target;
-                                const name = (types.isString(cmd) ? cmd.toUpperCase() : 'SET');
+                                const name = (isString(cmd) ? cmd.toUpperCase() : 'SET');
                                 switch (name) {
                                     case 'ARRAPPEND':
                                     case 'ARRINSERT': {
                                         let v1, v2;
-                                        if (types.isArray(v)) {
+                                        if (isArray(v)) {
                                             v1 = v[0];
                                             v2 = v.slice(1);
                                         }
@@ -343,7 +345,7 @@ async function executeBatchQuery(batch, options = '', outResult) {
                                         break;
                                     }
                                     case 'STRAPPEND':
-                                        if (types.isString(v)) {
+                                        if (isString(v)) {
                                             pending = client.json.strAppend(k, v, { path });
                                         }
                                         break;
@@ -389,7 +391,7 @@ async function executeBatchQuery(batch, options = '', outResult) {
                                         codeMin = NaN;
                                         pending = client.set(k, v, flags);
                                     }
-                                    else if (types.isObject(v)) {
+                                    else if (isObject(v)) {
                                         let valid = true;
                                         if (NX || XX) {
                                             valid = await client.exists(k) === 1;
@@ -430,7 +432,7 @@ async function executeBatchQuery(batch, options = '', outResult) {
                             }
                             if (pending) {
                                 pending.then(async (code) => {
-                                    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)) {
+                                    if (code == null || code !== -Infinity && isString(code) && code !== 'OK' || typeof code === 'number' && code <= codeMin || Array.isArray(code) && code.every(resp => resp === null || typeof resp === 'number' && resp <= codeMin)) {
                                         failValue();
                                         return;
                                     }
@@ -468,7 +470,7 @@ async function executeBatchQuery(batch, options = '', outResult) {
                                                 success(target);
                                             }
                                             else {
-                                                failed(types.errorMessage(f, "Invalid value", has(EX) ? 'EX: ' + EX : has(PX) ? 'PX: ' + PX : has(EXAT) ? 'EXAT: ' + EX : 'PXAT: ' + PXAT));
+                                                failed(errorMessage(f, "Invalid value", has(EX) ? 'EX: ' + EX : has(PX) ? 'PX: ' + PX : has(EXAT) ? 'EXAT: ' + EX : 'PXAT: ' + PXAT));
                                             }
                                         })
                                             .catch(failed);
@@ -499,39 +501,49 @@ async function executeBatchQuery(batch, options = '', outResult) {
                         }
                     });
                 }
-                const commandOptions = credential.commandOptions || clientOptions.command;
-                if (types.isPlainObject(commandOptions)) {
+                const commandOptions = credential.commandOptions;
+                if (isPlainObject(commandOptions)) {
                     commandOptions.abortSignal ||= this.signal;
                     client = client.withCommandOptions(commandOptions);
                 }
                 commandType = this.commandType.SELECT;
-                const target = types.isObject(search) ? search : types.isObject(aggregate) ? aggregate : null;
+                const target = isObject(search) ? search : isObject(aggregate) ? aggregate : null;
                 if (target) {
                     const { query = '', schema, index } = target;
+                    const ftType = () => target === search ? clientOptions.hybrid ? 'FT.HYBRID' : 'FT.SEARCH' : 'FT.AGGREGATE';
                     let idx = '';
-                    if (types.isObject(schema)) {
-                        idx = index || node_crypto.randomUUID();
+                    if (isObject(schema)) {
+                        idx = index || randomUUID();
                         await client.ft.create(idx, schema, target.options);
                     }
                     try {
                         if (target === search) {
-                            const reply = await client.ft.search(index || idx, query, clientOptions.search);
-                            rows = reply.documents.map(doc => (doc.value.__id__ = doc.id) && doc.value);
+                            if (clientOptions.hybrid) {
+                                const reply = await client.ft.hybrid(index || idx, clientOptions.hybrid);
+                                rows = reply.results;
+                                if (isArray(reply.warnings)) {
+                                    reply.warnings.forEach(msg => this.addLog(3, msg, "redis", 'FT.HYBRID'));
+                                }
+                            }
+                            else {
+                                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 client.ft.aggregate(index || idx, query, clientOptions.aggregate));
                         }
                     }
                     catch (err) {
-                        this.addLog(3, err, { source: target === search ? 'FT.SEARCH' : 'FT.AGGREGATE' });
-                        if (err instanceof Error) {
+                        this.addLog(3, err, "redis", ftType());
+                        if (isError(err)) {
                             throw err;
                         }
                     }
                     finally {
                         if (idx && idx !== index) {
                             client.ft.dropIndex(idx).catch((err) => {
-                                this.writeFail([`Unable to drop ${target === search ? 'search' : 'aggregate'} index`, idx], err, { type: 65536, fatal: false });
+                                this.writeFail([`Unable to drop ${ftType()} index`, idx], err, { type: 65536, fatal: false });
                             });
                         }
                     }
@@ -599,22 +611,20 @@ async function executeBatchQuery(batch, options = '', outResult) {
                     rows = (targetObject ? targetObject(item, data) : data);
                 }
                 if (rows == null) {
-                    throw types.errorMessage(source, "Missing database query");
+                    throw errorMessage(source, "Missing database query");
                 }
                 this.add(item, 4);
                 resolve(this.setQueryResult(source, DbPool.sanitize(redisCredential || credential), queryString, rows, cacheValue));
             }
             catch (err) {
-                if (err instanceof Error) {
-                    switch (err.message) {
-                        case "The client is closed":
-                        case "Disconnects client": {
-                            const pool = item.usePool && DbPool.findKey(POOL_STATE, item.usePool, DbPool.asString(credential));
-                            if (pool) {
-                                await pool.detach(true);
-                            }
-                            break;
+                switch (isError(err) && err.message) {
+                    case "The client is closed":
+                    case "Disconnects client": {
+                        const pool = item.usePool && DbPool.findKey(POOL_STATE, item.usePool, DbPool.asString(credential));
+                        if (pool) {
+                            await pool.detach(true);
                         }
+                        break;
                     }
                 }
                 if (this.handleFail(err, item, { errorQuery, commandType })) {
@@ -651,7 +661,7 @@ async function checkTimeout(value, limit = 0) {
     return DbPool.checkTimeout(POOL_STATE, value, limit);
 }
 const DB_SOURCE_CLIENT = true;
-const DB_SOURCE_TYPE = types.DB_TYPE.NOSQL | types.DB_TYPE.KEYVALUE;
+const DB_SOURCE_TYPE = DB_TYPE.NOSQL | DB_TYPE.KEYVALUE;
 
 exports.DB_SOURCE_CLIENT = DB_SOURCE_CLIENT;
 exports.DB_SOURCE_TYPE = DB_SOURCE_TYPE;

package/client/pool.js

@@ -1,3 +1,5 @@
+"use strict";
+
 const DbPool = require('@e-mc/db/pool');
 const POOL_ACTIVE = new WeakSet();
 class RedisPool extends DbPool {
@@ -36,4 +38,5 @@ class RedisPool extends DbPool {
         return !this.client.isOpen;
     }
 }
+
 module.exports = RedisPool;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-r/redis",
-  "version": "0.11.3",
+  "version": "0.12.0",
   "description": "Redis client driver for E-mc.",
   "main": "client/index.js",
   "types": "client/index.d.ts",
@@ -20,8 +20,8 @@
   "license": "MIT",
   "homepage": "https://github.com/anpham6/pi-r#readme",
   "dependencies": {
-    "@e-mc/db": "^0.13.10",
-    "@e-mc/types": "^0.13.10",
+    "@e-mc/db": "^0.14.0",
+    "@e-mc/types": "^0.14.0",
     "redis": "^5.12.1"
   }
 }

package/types/index.d.ts

@@ -11,6 +11,7 @@ import type { CommandOptions } from '@redis/client/dist/lib/client/commands-queu
 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 { FtHybridOptions } from '@redis/search/dist/lib/commands/HYBRID';
 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';
@@ -29,10 +30,9 @@ export interface RedisDataSource extends DbDataSource<string, PlainObject, Redis
     iterations?: number | number[];
     options?: {
         client?: RedisClientOptions;
-        /** @deprecated client.commandOptions */
-        command?: CommandOptions;
         get?: JsonGetOptions;
         search?: FtSearchOptions;
+        hybrid?: FtHybridOptions;
         aggregate?: FtAggregateOptions;
         xread?: XReadOptions;
         scan?: ScanOptions;
@@ -91,7 +91,7 @@ export type RedisCommandJSON = "ARRAPPEND" | "ARRINDEX" | "ARRINSERT" | "ARRPOP"
 export type RedisExpireCondition = "NX" | "XX" | "GT" | "LT";
 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 RedisClientPoolInstance = IRedisClientPoolType<any, any, any, any, any>;
 export type RedisHSETObject = Record<number | string, RedisCommandValue>;
 export type DbPoolCredential = RedisClientOptions & IdentifierAction;