@hotmeshio/hotmesh 0.0.60 → 0.1.1

package/build/services/store/clients/ioredis.js

@@ -7,7 +7,89 @@ class IORedisStoreService extends index_1.StoreService {
     constructor(redisClient) {
         super(redisClient);
     }
+    /**
+     * When in cluster mode, the getMulti wrapper only
+     * sends commands to the same node/shard.
+     * All other commands are sent simultaneously
+     * using Promise.all and are then collated
+     */
     getMulti() {
+        const my = this;
+        if (process.env.HMSH_IS_CLUSTER === 'true') {
+            const commands = [];
+            const addCommand = (command, args) => {
+                commands.push({ command, args });
+                return multiInstance;
+            };
+            const multiInstance = {
+                sendCommand(command) {
+                    return my.redisClient.sendCommand(command);
+                },
+                async exec() {
+                    if (commands.length === 0)
+                        return [];
+                    const sameCommand = commands.every(cmd => cmd.command === commands[0].command);
+                    if (sameCommand) {
+                        const multi = my.redisClient.multi();
+                        commands.forEach(cmd => multi[cmd.command](...cmd.args));
+                        const results = await multi.exec();
+                        return results.map(item => item); // Extract the results from multi.exec response format
+                    }
+                    else {
+                        return Promise.all(commands.map(cmd => my.redisClient[cmd.command](...cmd.args)));
+                    }
+                },
+                xadd(key, id, fields, message) {
+                    return addCommand('xadd', [key, id, fields, message]);
+                },
+                xack(key, group, id) {
+                    return addCommand('xack', [key, group, id]);
+                },
+                xdel(key, id) {
+                    return addCommand('xdel', [key, id]);
+                },
+                xlen(key) {
+                    return addCommand('xlen', [key]);
+                },
+                xpending(key, group, start, end, count, consumer) {
+                    return addCommand('xpending', [key, group, start, end, count, consumer]);
+                },
+                xclaim(key, group, consumer, minIdleTime, id, ...args) {
+                    return addCommand('xclaim', [key, group, consumer, minIdleTime, id, ...args]);
+                },
+                hdel(key, itemId) {
+                    return addCommand('hdel', [key, itemId]);
+                },
+                hget(key, itemId) {
+                    return addCommand('hget', [key, itemId]);
+                },
+                hgetall(key) {
+                    return addCommand('hgetall', [key]);
+                },
+                hincrbyfloat(key, itemId, value) {
+                    return addCommand('hincrbyfloat', [key, itemId, value]);
+                },
+                hmget(key, itemIds) {
+                    return addCommand('hmget', [key, itemIds]);
+                },
+                hset(key, values) {
+                    return addCommand('hset', [key, values]);
+                },
+                lrange(key, start, end) {
+                    return addCommand('lrange', [key, start, end]);
+                },
+                rpush(key, value) {
+                    return addCommand('rpush', [key, value]);
+                },
+                zadd(...args) {
+                    return addCommand('zadd', args);
+                },
+                xgroup(command, key, groupName, id, mkStream) {
+                    return addCommand('xgroup', [command, key, groupName, id, mkStream]);
+                }
+            };
+            return multiInstance;
+        }
         return this.redisClient.multi();
     }
     async exec(...args) {
@@ -43,7 +125,7 @@ class IORedisStoreService extends index_1.StoreService {
     async xgroup(command, key, groupName, id, mkStream) {
         if (mkStream === 'MKSTREAM') {
             try {
-                return (await this.redisClient.xgroup(command, key, groupName, id, mkStream)) === 'OK';
+                return ((await this.redisClient.xgroup(command, key, groupName, id, mkStream)) === 'OK');
             }
             catch (err) {
                 this.logger.debug(`Consumer group not created with MKSTREAM for key: ${key} and group: ${groupName}`);
@@ -52,7 +134,7 @@ class IORedisStoreService extends index_1.StoreService {
         }
         else {
             try {
-                return (await this.redisClient.xgroup(command, key, groupName, id)) === 'OK';
+                return ((await this.redisClient.xgroup(command, key, groupName, id)) === 'OK');
             }
             catch (err) {
                 this.logger.debug(`Consumer group not created for key: ${key} and group: ${groupName}`);
@@ -80,7 +162,7 @@ class IORedisStoreService extends index_1.StoreService {
     }
     async xclaim(key, group, consumer, minIdleTime, id, ...args) {
         try {
-            return await this.redisClient.xclaim(key, group, consumer, minIdleTime, id, ...args);
+            return (await this.redisClient.xclaim(key, group, consumer, minIdleTime, id, ...args));
         }
         catch (error) {
             this.logger.error(`Error in claiming message with id: ${id} in group: ${group} for key: ${key}`, { ...error });

package/build/services/store/clients/redis.d.ts

@@ -14,6 +14,12 @@ declare class RedisStoreService extends StoreService<RedisClientType, RedisMulti
     serializer: Serializer;
     commands: Record<string, string>;
     constructor(redisClient: RedisClientType);
+    /**
+     * When in cluster mode, the getMulti wrapper only
+     * sends commands to the same node/shard.
+     * All other commands are sent simultaneously
+     * using Promise.all and are then collated
+     */
     getMulti(): RedisMultiType;
     exec(...args: any[]): Promise<string | string[] | string[][]>;
     publish(keyType: KeyType.QUORUM, message: Record<string, any>, appId: string, engineId?: string): Promise<boolean>;

package/build/services/store/clients/redis.js

@@ -36,7 +36,123 @@ class RedisStoreService extends index_1.StoreService {
             xlen: 'XLEN',
         };
     }
+    /**
+     * When in cluster mode, the getMulti wrapper only
+     * sends commands to the same node/shard.
+     * All other commands are sent simultaneously
+     * using Promise.all and are then collated
+     */
     getMulti() {
+        const my = this;
+        if (process.env.HMSH_IS_CLUSTER === 'true') {
+            const commands = [];
+            const addCommand = (command, args) => {
+                commands.push({ command: command.toUpperCase(), args });
+                return multiInstance;
+            };
+            const multiInstance = {
+                sendCommand(command, ...args) {
+                    return my.redisClient.sendCommand([command, ...args]);
+                },
+                async exec() {
+                    if (commands.length === 0)
+                        return [];
+                    const sameCommand = commands.every(cmd => cmd.command === commands[0].command);
+                    if (sameCommand) {
+                        const multi = my.redisClient.multi();
+                        commands.forEach(cmd => {
+                            if (cmd.command === 'ZADD') {
+                                return multi.ZADD(cmd.args[0], cmd.args[1], cmd.args[2]);
+                            }
+                            return multi[cmd.command](...cmd.args);
+                        });
+                        const results = await multi.exec();
+                        return results.map(item => item); // Extract the results from multi.exec response format
+                    }
+                    else {
+                        return Promise.all(commands.map(cmd => {
+                            if (cmd.command === 'ZADD') {
+                                return my.redisClient.ZADD(cmd.args[0], cmd.args[1], cmd.args[2]);
+                            }
+                            return my.redisClient[cmd.command](...cmd.args);
+                        }));
+                    }
+                },
+                XADD(key, id, fields, message) {
+                    return addCommand('XADD', [key, id, fields, message]);
+                },
+                XACK(key, group, id) {
+                    return addCommand('XACK', [key, group, id]);
+                },
+                XDEL(key, id) {
+                    return addCommand('XDEL', [key, id]);
+                },
+                XLEN(key) {
+                    return addCommand('XLEN', [key]);
+                },
+                XCLAIM(key, group, consumer, minIdleTime, id, ...args) {
+                    return addCommand('XCLAIM', [key, group, consumer, minIdleTime, id, ...args]);
+                },
+                XPENDING(key, group, start, end, count, consumer) {
+                    return addCommand('XPENDING', [key, group, start, end, count, consumer]);
+                },
+                HDEL(key, itemId) {
+                    return addCommand('HDEL', [key, itemId]);
+                },
+                HGET(key, itemId) {
+                    return addCommand('HGET', [key, itemId]);
+                },
+                HGETALL(key) {
+                    return addCommand('HGETALL', [key]);
+                },
+                HINCRBYFLOAT(key, itemId, value) {
+                    return addCommand('HINCRBYFLOAT', [key, itemId, value]);
+                },
+                HMGET(key, itemIds) {
+                    return addCommand('HMGET', [key, itemIds]);
+                },
+                HSET(key, values) {
+                    return addCommand('HSET', [key, values]);
+                },
+                LRANGE(key, start, end) {
+                    return addCommand('LRANGE', [key, start, end]);
+                },
+                RPUSH(key, items) {
+                    return addCommand('RPUSH', [key, items]);
+                },
+                ZADD(key, args, opts) {
+                    return addCommand('ZADD', [key, args, opts]);
+                },
+                XGROUP(command, key, groupName, id, mkStream) {
+                    return addCommand('XGROUP', [command, key, groupName, id, mkStream]);
+                },
+                DEL: function (key) {
+                    throw new Error('Function not implemented.');
+                },
+                EXISTS: function (key) {
+                    throw new Error('Function not implemented.');
+                },
+                HMPUSH: function (key, values) {
+                    throw new Error('Function not implemented.');
+                },
+                LPUSH: function (key, items) {
+                    throw new Error('Function not implemented.');
+                },
+                SET: function (key, value) {
+                    throw new Error('Function not implemented.');
+                },
+                ZRANGE_WITHSCORES: function (key, start, end) {
+                    throw new Error('Function not implemented.');
+                },
+                ZRANK: function (key, member) {
+                    throw new Error('Function not implemented.');
+                },
+                ZSCORE: function (key, value) {
+                    throw new Error('Function not implemented.');
+                }
+            };
+            return multiInstance;
+        }
         return this.redisClient.multi();
     }
     async exec(...args) {
@@ -48,7 +164,10 @@ class RedisStoreService extends index_1.StoreService {
         return this.isSuccessful(status);
     }
     async zAdd(key, score, value, redisMulti) {
-        return await (redisMulti || this.redisClient)[this.commands.zadd](key, { score: score, value: value.toString() });
+        return await (redisMulti || this.redisClient)[this.commands.zadd](key, {
+            score: score,
+            value: value.toString(),
+        });
     }
     async zRangeByScoreWithScores(key, score, value) {
         const result = await this.redisClient[this.commands.zrangebyscore_withscores](key, score, value);
@@ -67,7 +186,14 @@ class RedisStoreService extends index_1.StoreService {
     async xgroup(command, key, groupName, id, mkStream) {
         const args = mkStream === 'MKSTREAM' ? ['MKSTREAM'] : [];
         try {
-            return (await this.redisClient.sendCommand(['XGROUP', 'CREATE', key, groupName, id, ...args])) === 1;
+            return ((await this.redisClient.sendCommand([
+                'XGROUP',
+                'CREATE',
+                key,
+                groupName,
+                id,
+                ...args,
+            ])) === 1);
         }
         catch (error) {
             const streamType = mkStream === 'MKSTREAM' ? 'with MKSTREAM' : 'without MKSTREAM';
@@ -81,7 +207,9 @@ class RedisStoreService extends index_1.StoreService {
             multi = args.pop();
         }
         try {
-            return await (multi || this.redisClient).XADD(key, id, { [args[0]]: args[1] });
+            return await (multi || this.redisClient).XADD(key, id, {
+                [args[0]]: args[1],
+            });
         }
         catch (error) {
             this.logger.error(`Error publishing 'xadd'; key: ${key}`, { ...error });
@@ -108,7 +236,15 @@ class RedisStoreService extends index_1.StoreService {
     }
     async xclaim(key, group, consumer, minIdleTime, id, ...args) {
         try {
-            return await this.redisClient.sendCommand(['XCLAIM', key, group, consumer, minIdleTime.toString(), id, ...args]);
+            return (await this.redisClient.sendCommand([
+                'XCLAIM',
+                key,
+                group,
+                consumer,
+                minIdleTime.toString(),
+                id,
+                ...args,
+            ]));
         }
         catch (error) {
             this.logger.error(`Error in claiming message with id: ${id} in group: ${group} for key: ${key}`, { ...error });

package/build/services/store/index.d.ts

@@ -1,7 +1,6 @@
 import { KeyStoreParams, KeyType } from '../../modules/key';
 import { ILogger } from '../logger';
 import { SerializerService as Serializer } from '../serializer';
-import { Cache } from './cache';
 import { ActivityType, Consumes } from '../../types/activity';
 import { AppVID } from '../../types/app';
 import { HookRule, HookSignal } from '../../types/hook';
@@ -12,6 +11,7 @@ import { Transitions } from '../../types/transition';
 import { ReclaimedMessageType } from '../../types/stream';
 import { JobCompletionOptions, JobInterruptOptions } from '../../types/job';
 import { WorkListTaskType } from '../../types/task';
+import { Cache } from './cache';
 interface AbstractRedisClient {
     exec(): any;
 }
@@ -50,7 +50,7 @@ declare abstract class StoreService<T, U extends AbstractRedisClient> {
     releaseScoutRole(scoutType: 'time' | 'signal' | 'activate'): Promise<boolean>;
     getSettings(bCreate?: boolean): Promise<HotMeshSettings>;
     setSettings(manifest: HotMeshSettings): Promise<any>;
-    reserveSymbolRange(target: string, size: number, type: 'JOB' | 'ACTIVITY'): Promise<[number, number, Symbols]>;
+    reserveSymbolRange(target: string, size: number, type: 'JOB' | 'ACTIVITY', tryCount?: number): Promise<[number, number, Symbols]>;
     getAllSymbols(): Promise<Symbols>;
     getSymbols(activityId: string): Promise<Symbols>;
     addSymbols(activityId: string, symbols: Symbols): Promise<boolean>;
@@ -134,7 +134,13 @@ declare abstract class StoreService<T, U extends AbstractRedisClient> {
      * organized into 'n'-second blocks (LISTS))
      */
     registerTimeHook(jobId: string, gId: string, activityId: string, type: WorkListTaskType, deletionTime: number, dad: string, multi?: U): Promise<void>;
-    getNextTask(listKey?: string): Promise<[listKey: string, jobId: string, gId: string, activityId: string, type: WorkListTaskType] | boolean>;
+    getNextTask(listKey?: string): Promise<[
+        listKey: string,
+        jobId: string,
+        gId: string,
+        activityId: string,
+        type: WorkListTaskType
+    ] | boolean>;
     /**
      * when processing time jobs, the target LIST ID returned
      * from the ZSET query can be prefixed to denote what to