@hotmeshio/hotmesh 0.1.15 → 0.1.16

package/build/services/pipe/functions/math.js

@@ -3,7 +3,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.MathHandler = void 0;
 class MathHandler {
     add(...operands) {
-        // @ts-ignore
         return operands.reduce((a, b) => {
             if (Array.isArray(b)) {
                 return a + this.add(...b);
@@ -38,7 +37,6 @@ class MathHandler {
         if (operands.length === 0) {
             throw new Error('At least one operand is required.');
         }
-        // @ts-ignore
         return operands.reduce((a, b) => {
             if (Array.isArray(b)) {
                 return a * this.multiply(...b);

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

@@ -13,23 +13,8 @@ declare class Pipe {
     static resolve(unresolved: {
         [key: string]: unknown;
     } | PipeItem, context: Partial<JobState>): any;
-    /**
-     * loop through each PipeItem row in this Pipe, resolving and transforming line by line
-     * @returns {any} the result of the pipe
-     */
     process(resolved?: unknown[] | null): any;
     cloneUnknown<T>(value: T): T;
-    /**
-     * Transforms iterable `input` into a single value. Vars $output, $item, $key
-     * and $input are available. The final statement in the iterator (the reduction)
-     * is assumed to be the return value. A default $output object may be provided
-     * to the iterator by placing the the second cell of the preceding row. Otherwise,
-     * construct the object during first run and ensure it is the first cell of the
-     * last row of the iterator, so it is returned as the $output for the next cycle
-     * @param {unknown[]} input
-     * @returns {unknown}
-     * @private
-     */
     reduce(input: Array<unknown[]>): unknown;
     private processRow;
     static resolveFunction(functionName: string): any;

package/build/services/pipe/index.js

@@ -33,16 +33,12 @@ class Pipe {
         }
         return pipe.process();
     }
-    /**
-     * loop through each PipeItem row in this Pipe, resolving and transforming line by line
-     * @returns {any} the result of the pipe
-     */
     process(resolved = null) {
         let index = 0;
         if (!(resolved ||
             this.isPipeType(this.rules[0]) ||
             this.isreduceType(this.rules[0]))) {
-            resolved = this.processCells(this.rules[0]); // Add type assertion
+            resolved = this.processCells(this.rules[0]);
             index = 1;
         }
         const len = this.rules.length;
@@ -73,17 +69,6 @@ class Pipe {
         }
         return clonedObj;
     }
-    /**
-     * Transforms iterable `input` into a single value. Vars $output, $item, $key
-     * and $input are available. The final statement in the iterator (the reduction)
-     * is assumed to be the return value. A default $output object may be provided
-     * to the iterator by placing the the second cell of the preceding row. Otherwise,
-     * construct the object during first run and ensure it is the first cell of the
-     * last row of the iterator, so it is returned as the $output for the next cycle
-     * @param {unknown[]} input
-     * @returns {unknown}
-     * @private
-     */
     reduce(input) {
         let resolved = this.cloneUnknown(input[1] ?? null);
         if (Array.isArray(input[0])) {
@@ -116,30 +101,25 @@ class Pipe {
     }
     processRow(currentRow, resolvedPriorRow, subPipeQueue) {
         if (resolvedPriorRow && this.isreduceType(currentRow)) {
-            //reduce the resolvedPriorRow and return the output from the reducer
             const subPipe = new Pipe(currentRow['@reduce'], this.jobData);
             const reduced = subPipe.reduce(resolvedPriorRow);
             return reduced;
         }
         else if (this.isPipeType(currentRow)) {
-            //process subPipe and push to subPipeQueue; echo resolvedPriorRow
             const subPipe = new Pipe(currentRow['@pipe'], this.jobData, this.context);
             subPipeQueue.push(subPipe.process());
             return resolvedPriorRow;
         }
         else {
-            //pivot the subPipeQueue into the arguments array (resolvedPriorRow)
             if (subPipeQueue.length > 0) {
                 resolvedPriorRow = [...subPipeQueue];
                 subPipeQueue.length = 0;
             }
             if (!resolvedPriorRow) {
-                //if no prior row, use current row as prior row
                 return [].concat(this.processCells(Array.isArray(currentRow) ? [...currentRow] : []));
             }
             else {
-                const [functionName, ...params] = currentRow; // Add type assertion
-                //use resolved values from prior row (n - 1) as input params to cell 1 function
+                const [functionName, ...params] = currentRow;
                 let resolvedValue;
                 if (this.isContextVariable(functionName)) {
                     resolvedValue = this.resolveContextValue(functionName);
@@ -147,7 +127,6 @@ class Pipe {
                 else {
                     resolvedValue = Pipe.resolveFunction(functionName)(...resolvedPriorRow);
                 }
-                //resolve remaining cells in row and return concatenated with resolvedValue
                 return [resolvedValue].concat(this.processCells([...params]));
             }
         }

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

@@ -21,6 +21,7 @@ declare class QuorumService {
     quorum: number | null;
     callbacks: QuorumMessageCallback[];
     rollCallInterval: NodeJS.Timeout;
+    constructor();
     static init(namespace: string, appId: string, guid: string, config: HotMeshConfig, engine: EngineService, logger: ILogger): Promise<QuorumService>;
     verifyQuorumFields(config: HotMeshConfig): void;
     initStoreChannel(store: RedisClient): Promise<void>;
@@ -28,10 +29,6 @@ declare class QuorumService {
     subscriptionHandler(): SubscriptionCallback;
     sayPong(appId: string, guid: string, originator: string, details?: boolean): Promise<void>;
     requestQuorum(delay?: number, details?: boolean): Promise<number>;
-    /**
-     * A quorum-wide command to broadcaset system details.
-     *
-     */
     doRollCall(message: RollCallMessage): Promise<void>;
     cancelRollCall(): void;
     stop(): void;
@@ -39,9 +36,6 @@ declare class QuorumService {
     sub(callback: QuorumMessageCallback): Promise<void>;
     unsub(callback: QuorumMessageCallback): Promise<void>;
     rollCall(delay?: number): Promise<QuorumProfile[]>;
-    /**
-     * request a quorum; if successful activate the app version
-     */
     activate(version: string, delay?: number, count?: number): Promise<boolean>;
 }
 export { QuorumService };

package/build/services/quorum/index.js

@@ -26,12 +26,9 @@ class QuorumService {
             instance.guid = guid;
             instance.logger = logger;
             instance.engine = engine;
-            //note: `quorum` shares/re-uses the engine's `store`/`sub` Redis clients
             await instance.initStoreChannel(config.engine.store);
             await instance.initSubChannel(config.engine.sub);
-            //general quorum subscription
             await instance.subscribe.subscribe(hotmesh_1.KeyType.QUORUM, instance.subscriptionHandler(), appId);
-            //app-specific quorum subscription (used for pubsub one-time request/response)
             await instance.subscribe.subscribe(hotmesh_1.KeyType.QUORUM, instance.subscriptionHandler(), appId, instance.guid);
             instance.engine.processWebHooks();
             instance.engine.processTimeHooks();
@@ -93,7 +90,6 @@ class QuorumService {
             else if (message.type === 'rollcall') {
                 self.doRollCall(message);
             }
-            //if there are any callbacks, call them
             if (self.callbacks.length > 0) {
                 self.callbacks.forEach((cb) => cb(topic, message));
             }
@@ -138,10 +134,6 @@ class QuorumService {
         await (0, utils_1.sleepFor)(delay);
         return quorum;
     }
-    /**
-     * A quorum-wide command to broadcaset system details.
-     *
-     */
     async doRollCall(message) {
         let iteration = 0;
         const max = !isNaN(message.max) ? message.max : enums_1.HMSH_QUORUM_ROLLCALL_CYCLES;
@@ -168,22 +160,15 @@ class QuorumService {
     stop() {
         this.cancelRollCall();
     }
-    // ************* PUB/SUB METHODS *************
-    //publish a message to the quorum
     async pub(quorumMessage) {
         return await this.store.publish(hotmesh_1.KeyType.QUORUM, quorumMessage, this.appId, quorumMessage.topic || quorumMessage.guid);
     }
-    //subscribe user to quorum messages
     async sub(callback) {
-        //the quorum is always subscribed to the `quorum` topic; just register the fn
         this.callbacks.push(callback);
     }
-    //unsubscribe user from quorum messages
     async unsub(callback) {
-        //the quorum is always subscribed to the `quorum` topic; just unregister the fn
         this.callbacks = this.callbacks.filter((cb) => cb !== callback);
     }
-    // ************* COMPILER METHODS *************
     async rollCall(delay = enums_1.HMSH_QUORUM_DELAY_MS) {
         await this.requestQuorum(delay, true);
         const targetStreams = [];
@@ -205,14 +190,10 @@ class QuorumService {
         });
         return this.profiles;
     }
-    /**
-     * request a quorum; if successful activate the app version
-     */
     async activate(version, delay = enums_1.HMSH_QUORUM_DELAY_MS, count = 0) {
         version = version.toString();
         const canActivate = await this.store.reserveScoutRole('activate', Math.ceil(delay * 6 / 1000) + 1);
         if (!canActivate) {
-            //another engine is already activating the app version
             this.logger.debug('quorum-activation-awaiting', { version });
             await (0, utils_1.sleepFor)(delay * 6);
             const app = await this.store.getApp(this.appId, true);
@@ -228,7 +209,6 @@ class QuorumService {
             this.store.publish(hotmesh_1.KeyType.QUORUM, { type: 'activate', cache_mode: 'nocache', until_version: version }, this.appId);
             await new Promise((resolve) => setTimeout(resolve, delay));
             await this.store.releaseScoutRole('activate');
-            //confirm we received the activation message
             if (this.engine.untilVersion === version) {
                 this.logger.info('quorum-activation-succeeded', { version });
                 const { id } = config;
@@ -244,7 +224,6 @@ class QuorumService {
             this.logger.warn('quorum-rollcall-error', { q1, q2, q3, count });
             this.store.releaseScoutRole('activate');
             if (count < enums_1.HMSH_ACTIVATION_MAX_RETRY) {
-                //increase the delay (give the quorum time to respond) and try again
                 return await this.activate(version, delay * 2, count + 1);
             }
             throw new Error(`Quorum not reached. Version ${version} not activated.`);

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

@@ -28,11 +28,6 @@ declare class ReporterService {
     getTargetForTime(key: string): string;
     getWorkItems(options: GetStatsOptions, facets: string[]): Promise<string[]>;
     private buildWorkerLists;
-    /**
-     * called by `trigger` activity to generate the stats that should
-     * be saved to the database. doesn't actually save the stats, but
-     * just generates the info that should be saved
-     */
     resolveTriggerStatistics({ stats: statsConfig }: TriggerActivity, context: JobState): StatsType;
     isGeneralMetric(metric: string): boolean;
     isMedianMetric(metric: string): boolean;

package/build/services/reporter/index.js

@@ -28,11 +28,9 @@ class ReporterService {
     }
     generateDateTimeSets(granularity, range, end, start) {
         if (granularity === 'infinity') {
-            //if granularity is infinity, it means a date/time sequence/slice is not used to further segment the statistics
             return ['0'];
         }
         if (!range) {
-            //pluck just a single value when no range provided
             range = '0m';
         }
         const granularitiesInMinutes = {
@@ -50,7 +48,6 @@ class ReporterService {
         if (rangeMinutes === null) {
             throw new Error('Invalid range value.');
         }
-        // If start is provided, use it. Otherwise, calculate it from the end time and range.
         let startTime;
         let endTime;
         if (start) {
@@ -61,7 +58,6 @@ class ReporterService {
             endTime = end === 'NOW' ? new Date() : new Date(end);
             startTime = new Date(endTime.getTime() - rangeMinutes * 60 * 1000);
         }
-        // Round the start time to the nearest granularity unit
         startTime.setUTCMinutes(Math.floor(startTime.getUTCMinutes() / granularityMinutes) *
             granularityMinutes);
         const dateTimeSets = [];
@@ -273,11 +269,6 @@ class ReporterService {
         }
         return workerLists;
     }
-    /**
-     * called by `trigger` activity to generate the stats that should
-     * be saved to the database. doesn't actually save the stats, but
-     * just generates the info that should be saved
-     */
     resolveTriggerStatistics({ stats: statsConfig }, context) {
         const stats = {
             general: [],

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

@@ -30,15 +30,6 @@ declare class Router {
     private resetThrottleState;
     createGroup(stream: string, group: string): Promise<void>;
     publishMessage(topic: string, streamData: StreamData | StreamDataResponse, multi?: RedisMulti): Promise<string | RedisMulti>;
-    /**
-     * An adjustable throttle that will interrupt a sleeping
-     * router if the throttle is reduced and the sleep time
-     * has elapsed. If the throttle is increased, or if
-     * the sleep time has not elapsed, the router will continue
-     * to sleep until the new termination point. This
-     * allows for dynamic, elastic throttling with smooth
-     * acceleration and deceleration.
-     */
     customSleep(): Promise<void>;
     consumeMessages(stream: string, group: string, consumer: string, callback: (streamData: StreamData) => Promise<StreamDataResponse | void>): Promise<void>;
     isStreamMessage(result: any): boolean;

package/build/services/router/index.js

@@ -51,22 +51,13 @@ class Router {
         });
         return await this.store.xadd(stream, '*', 'message', JSON.stringify(streamData), multi);
     }
-    /**
-     * An adjustable throttle that will interrupt a sleeping
-     * router if the throttle is reduced and the sleep time
-     * has elapsed. If the throttle is increased, or if
-     * the sleep time has not elapsed, the router will continue
-     * to sleep until the new termination point. This
-     * allows for dynamic, elastic throttling with smooth
-     * acceleration and deceleration.
-     */
     async customSleep() {
         if (this.throttle === 0)
             return;
         if (this.isSleeping)
             return;
         this.isSleeping = true;
-        const startTime = Date.now(); //anchor the origin
+        const startTime = Date.now();
         await new Promise(async (outerResolve) => {
             this.sleepPromiseResolve = outerResolve;
             let elapsedTime = Date.now() - startTime;
@@ -97,7 +88,6 @@ class Router {
                 return;
             }
             try {
-                //randomizer that asymptotes at 150% of `HMSH_BLOCK_TIME_MS`
                 const streamDuration = enums_1.HMSH_BLOCK_TIME_MS + Math.round(enums_1.HMSH_BLOCK_TIME_MS * Math.random());
                 const result = await this.stream.xreadgroup('GROUP', group, consumer, 'BLOCK', streamDuration, 'STREAMS', stream, '>');
                 if (this.isStopped(group, consumer, stream)) {
@@ -113,7 +103,6 @@ class Router {
                         await this.consumeOne(stream, group, id, message, callback);
                     }
                 }
-                // Check for pending messages (note: Redis 6.2 simplifies)
                 const now = Date.now();
                 if (now - lastCheckedPendingMessagesAt > this.reclaimDelay) {
                     lastCheckedPendingMessagesAt = now;
@@ -213,7 +202,6 @@ class Router {
                     await (0, utils_1.sleepFor)(timeout);
                     return (await this.publishMessage(input.metadata.topic, {
                         data: input.data,
-                        //note: retain guid (this is a retry attempt)
                         metadata: { ...input.metadata, try: (input.metadata.try || 0) + 1 },
                         policies: input.policies,
                     }));
@@ -233,16 +221,12 @@ class Router {
         }
     }
     shouldRetry(input, output) {
-        //const isUnhandledEngineError = output.code === 500;
         const policies = input.policies?.retry;
         const errorCode = output.code.toString();
         const policy = policies?.[errorCode];
         const maxRetries = policy?.[0];
         const tryCount = Math.min(input.metadata.try || 0, enums_1.HMSH_MAX_RETRIES);
-        //only possible values for maxRetries are 1, 2, 3
-        //only possible values for tryCount are 0, 1, 2
         if (maxRetries > tryCount) {
-            // 10ms, 100ms, or 1000ms delays between system retries
             return [true, Math.pow(10, tryCount + 1)];
         }
         return [false, 0];
@@ -278,7 +262,6 @@ class Router {
             code,
             data,
         };
-        //send unacknowleded errors to the engine (it has no topic)
         delete output.metadata.topic;
         return output;
     }
@@ -330,7 +313,6 @@ class Router {
         }
         const wasDecreased = delayInMillis < this.throttle;
         this.throttle = delayInMillis;
-        // If the throttle was decreased, and we're in the middle of a sleep cycle, adjust immediately
         if (wasDecreased) {
             if (this.sleepTimout) {
                 clearTimeout(this.sleepTimout);
@@ -342,7 +324,7 @@ class Router {
     }
     async claimUnacknowledged(stream, group, consumer, idleTimeMs = this.reclaimDelay, limit = enums_1.HMSH_XPENDING_COUNT) {
         let pendingMessages = [];
-        const pendingMessagesInfo = await this.stream.xpending(stream, group, '-', '+', limit); //[[ '1688768134881-0', 'testConsumer1', 1017, 1 ]]
+        const pendingMessagesInfo = await this.stream.xpending(stream, group, '-', '+', limit);
         for (const pendingMessageInfo of pendingMessagesInfo) {
             if (Array.isArray(pendingMessageInfo)) {
                 const [id, , elapsedTimeMs, deliveryCount] = pendingMessageInfo;
@@ -362,13 +344,6 @@ class Router {
         return pendingMessages;
     }
     async expireUnacknowledged(reclaimedMessage, stream, group, consumer, id, count) {
-        //The stream activity was not processed within established limits. Possibilities Include:
-        // 1) user error: the workers were not properly configured and are timing out
-        // 2a) system error: JSON is corrupt
-        //     i) unwitting actor
-        //     ii) corrupt hardware/network/transport/etc
-        // 3b) system error: Redis unable to accept `xadd` request
-        // 4c) system error: Redis unable to accept `xdel`/`xack` request
         this.logger.error('stream-message-max-delivery-count-exceeded', {
             id,
             stream,
@@ -378,7 +353,6 @@ class Router {
             count,
         });
         const streamData = reclaimedMessage[0]?.[1]?.[1];
-        //fatal risk point 1 of 3): json is corrupt
         const [err, input] = this.parseStreamData(streamData);
         if (err) {
             return this.logger.error('expire-unacknowledged-parse-fatal-error', {
@@ -397,11 +371,9 @@ class Router {
             telemetry = new telemetry_1.TelemetryService(this.appId);
             telemetry.startStreamSpan(input, stream_1.StreamRole.SYSTEM);
             telemetry.setStreamError(`Stream Message Max Delivery Count Exceeded`);
-            //fatal risk point 2 of 3): unable to publish error message (to notify the parent job)
             const output = this.structureUnacknowledgedError(input);
             messageId = await this.publishResponse(input, output);
             telemetry.setStreamAttributes({ 'app.worker.mid': messageId });
-            //fatal risk point 3 of 3): unable to ack and delete stream message
             await this.ackAndDelete(stream, group, id);
         }
         catch (err) {

package/build/services/serializer/index.js

@@ -69,7 +69,6 @@ class SerializerService {
                 return this.dIds[activityId];
             }
             else if ('$ADJACENT' in this.dIds) {
-                //else=> pre-authorizing adjacent activity entry
                 return this.dIds['$ADJACENT'];
             }
             return ',0';
@@ -140,7 +139,6 @@ class SerializerService {
                     result[shortDimensionalKey] = source[key];
                 }
                 else if (!(key in result) && this.isLiteralKeyType(key)) {
-                    //mark (-) and search (_)
                     result[key] = source[key];
                 }
             }
@@ -164,7 +162,6 @@ class SerializerService {
         const inflateWithMap = (abbreviationMap, id) => {
             const reversedAbbreviationMap = this.getReverseKeyMap(abbreviationMap, id);
             for (const key in result) {
-                //strip dimensional index from key
                 const shortKey = key.split(',')[0];
                 const longKey = reversedAbbreviationMap.get(shortKey);
                 if (longKey) {
@@ -181,36 +178,22 @@ class SerializerService {
         }
         return result;
     }
-    //stringify: convert a multi-dimensional document to a 2-d hash
     stringify(document) {
         const result = {};
         for (const key in document) {
             const value = SerializerService.toString(document[key]);
             if (value) {
-                // if (/^:*[a-zA-Z]{2}$/.test(value)) {
-                //   value = ':' + value;
-                // } else if (this.symValReverseMaps.has(value)) {
-                //   value = this.symValReverseMaps.get(value);
-                // }
                 result[key] = value;
             }
         }
         return result;
     }
-    //parse: convert a 2-d hash to a multi-dimensional document
     parse(document) {
         const result = {};
         for (const [key, value] of Object.entries(document)) {
             if (value === undefined || value === null)
                 continue;
-            // if (/^:+[a-zA-Z]{2}$/.test(value)) {
-            //   result[key] = value.slice(1);
-            // } else {
-            //   if (value?.length === 2 && this.symValMaps.has(value)) {
-            //     value = this.symValMaps.get(value);
-            //   }
             result[key] = SerializerService.fromString(value);
-            // }
         }
         return result;
     }
@@ -243,20 +226,20 @@ class SerializerService {
         const prefix = value.slice(0, 2);
         const rest = value.slice(2);
         switch (prefix) {
-            case '/t': // boolean true
+            case '/t':
                 return true;
-            case '/f': // boolean false
+            case '/f':
                 return false;
-            case '/d': // number
+            case '/d':
                 return Number(rest);
-            case '/n': // null
+            case '/n':
                 return null;
-            case '/s': // object (JSON string)
+            case '/s':
                 if (dateReg.exec(rest)) {
                     return new Date(JSON.parse(rest));
                 }
                 return JSON.parse(rest);
-            default: // string
+            default:
                 return value;
         }
     }

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

@@ -1,10 +1,3 @@
-/**
- * The Cache is a key/value store and used to store commonly accessed Redis metadata
- * (mainly the execution rules for the app) to save time accessing them as they
- * are immutable per verison. Rules are only ejected when a new version
- * (a new distributed executable) is deployed to the quorum
- * and the cache is invalidated/cleared of the prior version.
- */
 import { ActivityType } from '../../types/activity';
 import { HookRule } from '../../types/hook';
 import { HotMeshApp, HotMeshSettings } from '../../types/hotmesh';
@@ -21,19 +14,7 @@ declare class Cache {
     transitions: Record<string, Record<string, unknown>>;
     hookRules: Record<string, Record<string, HookRule[]>>;
     workItems: Record<string, string>;
-    /**
-     * The cache is ALWAYS initialized with HotMeshSettings. The other parameters are optional.
-     * @param settings
-     * @param apps
-     * @param schemas
-     * @param subscriptions
-     * @param transitions
-     * @param hookRules
-     */
     constructor(appId: string, settings: HotMeshSettings, apps?: Record<string, HotMeshApp>, schemas?: Record<string, ActivityType>, subscriptions?: Record<string, Record<string, string>>, symbols?: Record<string, Symbols>, symvals?: Record<string, Symbols>, transitions?: Record<string, Record<string, unknown>>, hookRules?: Record<string, Record<string, HookRule[]>>, workItems?: Record<string, string>);
-    /**
-     * invalidate the cache; settings are not invalidated!
-     */
     invalidate(): void;
     getSettings(): HotMeshSettings;
     setSettings(settings: HotMeshSettings): void;

package/build/services/store/cache.js

@@ -1,23 +1,7 @@
 "use strict";
-/**
- * The Cache is a key/value store and used to store commonly accessed Redis metadata
- * (mainly the execution rules for the app) to save time accessing them as they
- * are immutable per verison. Rules are only ejected when a new version
- * (a new distributed executable) is deployed to the quorum
- * and the cache is invalidated/cleared of the prior version.
- */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Cache = void 0;
 class Cache {
-    /**
-     * The cache is ALWAYS initialized with HotMeshSettings. The other parameters are optional.
-     * @param settings
-     * @param apps
-     * @param schemas
-     * @param subscriptions
-     * @param transitions
-     * @param hookRules
-     */
     constructor(appId, settings, apps = {}, schemas = {}, subscriptions = {}, symbols = {}, symvals = {}, transitions = {}, hookRules = {}, workItems = {}) {
         this.appId = appId;
         this.settings = settings;
@@ -30,9 +14,6 @@ class Cache {
         this.hookRules = hookRules;
         this.workItems = workItems;
     }
-    /**
-     * invalidate the cache; settings are not invalidated!
-     */
     invalidate() {
         this.apps = {};
         this.schemas = {};

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

@@ -13,12 +13,6 @@ declare class IORedisStoreService extends StoreService<RedisClientType, RedisMul
     logger: ILogger;
     serializer: Serializer;
     constructor(redisClient: RedisClientType);
-    /**
-     * When in cluster mode, the getMulti wrapper only
-     * sends commands to the same node/shard if they share a key.
-     * All other commands are sent simultaneouslyusing Promise.all
-     * and are then collated
-     */
     getMulti(): RedisMultiType;
     exec(...args: any[]): Promise<string | string[] | string[][]>;
     hGetAllResult(result: any): any;

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

@@ -8,12 +8,6 @@ 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 if they share a key.
-     * All other commands are sent simultaneouslyusing Promise.all
-     * and are then collated
-     */
     getMulti() {
         const my = this;
         if (enums_1.HMSH_IS_CLUSTER) {
@@ -129,7 +123,6 @@ class IORedisStoreService extends index_1.StoreService {
         return response;
     }
     hGetAllResult(result) {
-        //ioredis response signature is [null, {}] or [null, null]
         return result[1];
     }
     async addTaskQueues(keys) {

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

@@ -14,12 +14,6 @@ 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 if they share a key.
-     * All other commands are sent simultaneouslyusing 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

@@ -37,12 +37,6 @@ class RedisStoreService extends index_1.StoreService {
             xlen: 'XLEN',
         };
     }
-    /**
-     * When in cluster mode, the getMulti wrapper only
-     * sends commands to the same node/shard if they share a key.
-     * All other commands are sent simultaneouslyusing Promise.all
-     * and are then collated
-     */
     getMulti() {
         const my = this;
         if (enums_1.HMSH_IS_CLUSTER) {