@pi-r/redis 0.7.3 → 0.8.1

package/client/index.js

@@ -1,26 +1,31 @@
 "use strict";
-exports.DB_SOURCE_TYPE = exports.DB_SOURCE_CLIENT = exports.checkTimeout = exports.executeBatchQuery = exports.executeQuery = exports.setCredential = void 0;
+exports.DB_SOURCE_TYPE = exports.DB_SOURCE_CLIENT = void 0;
+exports.setCredential = setCredential;
+exports.executeQuery = executeQuery;
+exports.executeBatchQuery = executeBatchQuery;
+exports.checkTimeout = checkTimeout;
 const redis = require("redis");
+const crypto_1 = require("crypto");
+const Db = require("@e-mc/db");
 const util_1 = require("@e-mc/db/util");
 const types_1 = require("@e-mc/types");
-const Db = require("@e-mc/db");
-const DbPool = require('@e-mc/db/pool');
-class RedisPool extends DbPool {
-    async getConnection() {
-        return this.client;
-    }
-    async close() {
-        return this.client.disconnect();
-    }
-    isEmpty() {
-        return this.closed;
+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];
     }
-    get closed() {
-        return !this.client.isOpen;
+    if (!Array.isArray(iterations)) {
+        iterations = [iterations];
     }
+    let result = [], current = cursor[index] ?? 0, length = iterations[index] ?? Infinity;
+    do {
+        const item = await client.hScan(key, current, options);
+        result = result.concat(item.tuples);
+        current = item.cursor;
+    } while (current > 0 && --length > 0);
+    return result;
 }
-const POOL_STATE = {};
-const POOL_ACTIVE = new WeakSet();
 async function getClient(db, options, poolKey) {
     const socket = options.socket ||= {};
     if (!poolKey) {
@@ -36,16 +41,13 @@ async function getClient(db, options, poolKey) {
                 delete POOL_STATE[poolKey];
             });
         }
-        client.connect().then(() => resolve(client)).catch((err) => reject(err));
+        client.connect().then(() => {
+            resolve(client);
+        }).catch((err) => {
+            reject(err);
+        });
     });
 }
-function removePoolProperties(options) {
-    if (!options.uuidKey && ('socket' in options || 'isolationPoolOptions' in options) && POOL_ACTIVE.has(options)) {
-        return { ...options, socket: options.socket?.tls ? { tls: true } : undefined, isolationPoolOptions: undefined };
-    }
-    return options;
-}
-const getPoolKey = (options) => options.url && JSON.stringify(options);
 async function setCredential(item) {
     const credential = this.getCredential(item);
     const options = item.options ||= {};
@@ -122,26 +124,24 @@ async function setCredential(item) {
             poolOptions.acquireTimeoutMillis ??= timeout;
         }
     }
-    const poolKey = getPoolKey(client);
+    const poolKey = DbPool.asString(client);
     if ((pool = POOL_STATE[poolKey]) && !pool.closed) {
         pool.add(item);
         return;
     }
     try {
-        const target = new RedisPool(await getClient(redis, client, poolKey), poolKey, username && password ? { username, password } : undefined).add(item);
-        target.parent = POOL_STATE;
-        target.success = 1;
+        const instance = new DbPool(await getClient(redis, client, poolKey), poolKey, username && password ? { username, password } : undefined).add(item);
+        instance.parent = POOL_STATE;
+        instance.success = 1;
     }
     catch {
         item.usePool = false;
         delete client.isolationPoolOptions;
     }
 }
-exports.setCredential = setCredential;
 async function executeQuery(item, options) {
     return (await executeBatchQuery.call(this, [item], options))[0] || [];
 }
-exports.executeQuery = executeQuery;
 async function executeBatchQuery(batch, options = '', outResult) {
     const length = batch.length;
     if (length === 0) {
@@ -162,7 +162,7 @@ async function executeBatchQuery(batch, options = '', outResult) {
         parallel = false;
     }
     else if (parallel === undefined) {
-        parallel = !batch.some(item => item.parallel === false || !!item.update);
+        parallel = !batch.some(item => item.parallel === false);
     }
     if (!parallel) {
         outResult ||= new Array(length);
@@ -175,11 +175,10 @@ async function executeBatchQuery(batch, options = '', outResult) {
         item.transactionState = 64;
         let client;
         if (item.usePool) {
-            const pool = DbPool.findKey(POOL_STATE, item.usePool, getPoolKey(credential), ...connectOnce ? [item, batch[0]] : [item]);
+            const pool = DbPool.findKey(POOL_STATE, item.usePool, DbPool.asString(credential), ...connectOnce ? [item, batch[0]] : [item]);
             if (pool) {
-                client = pool.client;
+                client = await pool.getConnection(credential);
                 pool.connected = true;
-                POOL_ACTIVE.add(credential);
             }
         }
         if (!client) {
@@ -245,7 +244,7 @@ async function executeBatchQuery(batch, options = '', outResult) {
                 queryString += '_' + format;
             }
             if (ignoreCache !== 1) {
-                if (rows = this.getQueryResult(source, removePoolProperties(credential), queryString, cacheValue)) {
+                if (rows = this.getQueryResult(source, DbPool.sanitize(credential), queryString, cacheValue)) {
                     ++redisCache;
                     if (parallel) {
                         tasks[i] = Promise.resolve(rows);
@@ -288,8 +287,12 @@ async function executeBatchQuery(batch, options = '', outResult) {
                                 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 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);
                             let pending, codeMin = 0, EX, PX, EXAT, PXAT, KEEPTTL;
                             if (f === 'JSON') {
@@ -342,7 +345,7 @@ async function executeBatchQuery(batch, options = '', outResult) {
                                             m.path ||= path;
                                             return m;
                                         });
-                                        if (data.length) {
+                                        if (data.length > 0) {
                                             pending = commandSet ? client.json.mSet(commandSet, data) : client.json.mSet(data);
                                         }
                                         break;
@@ -482,13 +485,17 @@ async function executeBatchQuery(batch, options = '', outResult) {
                                                 failed((0, types_1.errorMessage)(f, "Invalid value", has(EX) ? 'EX: ' + EX : has(PX) ? 'PX: ' + PX : has(EXAT) ? 'EXAT: ' + EX : 'PXAT: ' + PXAT));
                                             }
                                         })
-                                            .catch((err) => failed(err));
+                                            .catch((err) => {
+                                            failed(err);
+                                        });
                                     }
                                     else {
                                         success(target);
                                     }
                                 })
-                                    .catch((err) => failed(err));
+                                    .catch((err) => {
+                                    failed(err);
+                                });
                             }
                             else {
                                 failValue();
@@ -516,7 +523,7 @@ async function executeBatchQuery(batch, options = '', outResult) {
                     const { query = '', schema, index } = target;
                     let idx = '';
                     if ((0, types_1.isObject)(schema)) {
-                        idx = index || (0, types_1.generateUUID)();
+                        idx = index || (0, crypto_1.randomUUID)();
                         await (command ? client.ft.create(command, idx, schema, target.options) : client.ft.create(idx, schema, target.options));
                     }
                     try {
@@ -535,7 +542,9 @@ async function executeBatchQuery(batch, options = '', outResult) {
                     }
                     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 }));
+                            client.ft.dropIndex(idx).catch((err) => {
+                                this.writeFail([`Unable to drop ${target === search ? 'search' : 'aggregate'} index`, idx], err, { type: 65536, fatal: false });
+                            });
                         }
                     }
                 }
@@ -549,6 +558,9 @@ async function executeBatchQuery(batch, options = '', outResult) {
                             case 'HVALS':
                                 data = await Promise.all(key.map(async (k) => client.hVals(...command ? [command, k] : [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 '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();
                                 break;
@@ -565,6 +577,9 @@ async function executeBatchQuery(batch, options = '', outResult) {
                             case 'HVALS':
                                 data = await client.hVals(...command ? [command, key] : [key]);
                                 break;
+                            case 'HSCAN':
+                                data = await doScan(client, key, 0, item.cursor, item.iterations, clientOptions.scan);
+                                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)]));
                                 break;
@@ -584,14 +599,14 @@ async function executeBatchQuery(batch, options = '', outResult) {
                     throw (0, types_1.errorMessage)(source, "Missing database query");
                 }
                 this.add(item, 4);
-                resolve(this.setQueryResult(source, removePoolProperties(redisCredential || credential), queryString, rows, cacheValue));
+                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, getPoolKey(credential));
+                            const pool = item.usePool && DbPool.findKey(POOL_STATE, item.usePool, DbPool.asString(credential));
                             if (pool) {
                                 await pool.detach(true);
                             }
@@ -618,16 +633,16 @@ async function executeBatchQuery(batch, options = '', outResult) {
         }
     }
     return this.processRows(batch, tasks, {
-        disconnect: () => clients.forEach(item => {
-            item.disconnect();
-        }),
-        parallel
+        parallel,
+        disconnect() {
+            for (const item of clients) {
+                void item.disconnect();
+            }
+        }
     }, outResult);
 }
-exports.executeBatchQuery = executeBatchQuery;
 async function checkTimeout(value, limit = 0) {
     return DbPool.checkTimeout(POOL_STATE, value, limit);
 }
-exports.checkTimeout = checkTimeout;
 exports.DB_SOURCE_CLIENT = true;
 exports.DB_SOURCE_TYPE = types_1.DB_TYPE.NOSQL | types_1.DB_TYPE.KEYVALUE;

package/client/pool.d.ts

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

package/client/pool.js

@@ -0,0 +1,36 @@
+"use strict";
+const DbPool = require('@e-mc/db/pool');
+const POOL_ACTIVE = new WeakSet();
+class RedisPool extends DbPool {
+    static asString(credential) {
+        if (credential.url) {
+            return JSON.stringify(credential);
+        }
+        return super.asString(credential);
+    }
+    static sanitize(credential) {
+        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 };
+        }
+        return credential;
+    }
+    async getConnection(credential) {
+        if (credential) {
+            POOL_ACTIVE.add(credential);
+        }
+        return this.client;
+    }
+    async close() {
+        return this.client.disconnect();
+    }
+    isEmpty() {
+        return this.closed;
+    }
+    get closed() {
+        return !this.client.isOpen;
+    }
+}
+module.exports = RedisPool;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-r/redis",
-  "version": "0.7.3",
+  "version": "0.8.1",
   "description": "Redis client driver for E-mc.",
   "main": "client/index.js",
   "types": "client/index.d.ts",
@@ -21,8 +21,8 @@
   "license": "MIT",
   "homepage": "https://github.com/anpham6/pi-r#readme",
   "dependencies": {
-    "@e-mc/db": "^0.9.6",
-    "@e-mc/types": "^0.9.6",
-    "redis": "^4.6.15"
+    "@e-mc/db": "^0.10.0",
+    "@e-mc/types": "^0.10.0",
+    "redis": "^4.7.0"
   }
 }

package/types/index.d.ts

@@ -1,12 +1,16 @@
 import type { DbDataSource } from '@e-mc/types/lib/squared';
 
+import type { IdentifierAction } from '@e-mc/types/lib/core';
 import type { CascadeAction, ServerAuth } from '@e-mc/types/lib/db';
 
-import type { CommandOptions } from '@redis/client/dist/lib/command-options';
 import type { ClientCommandOptions } from '@redis/client/dist/lib/client';
-import type { RedisClientOptions } from '@redis/client';
 import type { RedisCommandArgument } from '@redis/client/dist/lib/commands';
+import type { CommandOptions } from '@redis/client/dist/lib/command-options';
+import type { RedisClientOptions } from '@redis/client';
 import type { RedisJSON } from '@redis/json/dist/commands';
+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, SearchOptions, SetOptions } from 'redis';
 
 export interface RedisDataSource extends DbDataSource<string, PlainObject, ArrayOf<RedisSetValue> | ArrayOf<RedisJSONValue>, RedisCredential, string>, CascadeAction, AuthValue {
@@ -14,15 +18,18 @@ export interface RedisDataSource extends DbDataSource<string, PlainObject, Array
     key?: ArrayOf<RedisCommandArgument>;
     field?: RedisCommandArgument;
     path?: string;
-    format?: RedisFormat | "HKEYS" | "HVALS";
+    format?: RedisFormat | "HKEYS" | "HVALS" | "HSCAN";
     search?: RedisQuery;
     aggregate?: RedisQuery;
+    cursor?: ArrayOf<number>;
+    iterations?: ArrayOf<number>;
     options?: {
         client?: RedisClientOptions;
         command?: RedisCommandOptions;
         get?: PlainObject;
         search?: SearchOptions;
-        aggregate?: PlainObject;
+        aggregate?: AggregateOptions;
+        scan?: ScanOptions;
     };
     database?: number;
 }
@@ -79,5 +86,6 @@ export type RedisExpireCondition = "NX" | "XX" | "GT" | "LT";
 export type RedisCommandValue = RedisCommandArgument | number;
 export type RedisCommandOptions = CommandOptions<ClientCommandOptions>;
 export type RedisHSETObject = Record<number | string, RedisCommandValue>;
+export type DbPoolCredential = RedisClientOptions & IdentifierAction;
 
-export type { RedisCommandArgument, RedisJSON };
+export type { HScanTuple, RedisCommandArgument, RedisJSON, ScanOptions };