@hotmeshio/hotmesh 0.0.60 → 0.1.1

package/build/services/pipe/index.js

@@ -18,7 +18,10 @@ class Pipe {
         return !Array.isArray(currentRow) && '@reduce' in currentRow;
     }
     static isPipeObject(obj) {
-        return typeof obj === 'object' && obj !== null && !Array.isArray(obj) && '@pipe' in obj;
+        return (typeof obj === 'object' &&
+            obj !== null &&
+            !Array.isArray(obj) &&
+            '@pipe' in obj);
     }
     static resolve(unresolved, context) {
         let pipe;
@@ -36,7 +39,9 @@ class Pipe {
      */
     process(resolved = null) {
         let index = 0;
-        if (!(resolved || this.isPipeType(this.rules[0]) || this.isreduceType(this.rules[0]))) {
+        if (!(resolved ||
+            this.isPipeType(this.rules[0]) ||
+            this.isreduceType(this.rules[0]))) {
             resolved = this.processCells(this.rules[0]); // Add type assertion
             index = 1;
         }
@@ -58,7 +63,7 @@ class Pipe {
             return new RegExp(value);
         }
         if (Array.isArray(value)) {
-            return value.map(item => this.cloneUnknown(item));
+            return value.map((item) => this.cloneUnknown(item));
         }
         const clonedObj = {};
         for (const key in value) {
@@ -83,15 +88,27 @@ class Pipe {
         let resolved = this.cloneUnknown(input[1] ?? null);
         if (Array.isArray(input[0])) {
             for (let index = 0; index < input[0].length; index++) {
-                this.context = { $input: input[0], $output: resolved, $item: input[0][index], $key: index.toString(), $index: index };
+                this.context = {
+                    $input: input[0],
+                    $output: resolved,
+                    $item: input[0][index],
+                    $key: index.toString(),
+                    $index: index,
+                };
                 resolved = this.process([resolved]);
             }
         }
         else {
             let index = -1;
-            for (let $key in input[0]) {
+            for (const $key in input[0]) {
                 index++;
-                this.context = { $input: input[0], $output: resolved, $item: input[0][$key], $key, $index: index };
+                this.context = {
+                    $input: input[0],
+                    $output: resolved,
+                    $item: input[0][$key],
+                    $key,
+                    $index: index,
+                };
                 resolved = this.process([resolved]);
             }
         }
@@ -158,15 +175,23 @@ class Pipe {
         return resolved;
     }
     isFunction(currentCell) {
-        return typeof currentCell === 'string' && currentCell.startsWith('{@') && currentCell.endsWith('}');
+        return (typeof currentCell === 'string' &&
+            currentCell.startsWith('{@') &&
+            currentCell.endsWith('}'));
     }
     isContextVariable(currentCell) {
         if (typeof currentCell === 'string' && currentCell.endsWith('}')) {
-            return currentCell.startsWith('{$item') || currentCell.startsWith('{$key') || currentCell.startsWith('{$index') || currentCell.startsWith('{$input') || currentCell.startsWith('{$output');
+            return (currentCell.startsWith('{$item') ||
+                currentCell.startsWith('{$key') ||
+                currentCell.startsWith('{$index') ||
+                currentCell.startsWith('{$input') ||
+                currentCell.startsWith('{$output'));
         }
     }
     isMappable(currentCell) {
-        return typeof currentCell === 'string' && currentCell.startsWith('{') && currentCell.endsWith('}');
+        return (typeof currentCell === 'string' &&
+            currentCell.startsWith('{') &&
+            currentCell.endsWith('}'));
     }
     resolveCellValue(currentCell) {
         if (this.isFunction(currentCell)) {
@@ -187,7 +212,9 @@ class Pipe {
         const pathParts = path.split('.');
         let current = obj;
         for (const part of pathParts) {
-            if (current === null || typeof current !== 'object' || !current.hasOwnProperty(part)) {
+            if (current === null ||
+                typeof current !== 'object' ||
+                !current.hasOwnProperty(part)) {
                 return undefined;
             }
             current = current[part];

package/build/services/quorum/index.js

@@ -95,14 +95,16 @@ class QuorumService {
             }
             //if there are any callbacks, call them
             if (self.callbacks.length > 0) {
-                self.callbacks.forEach(cb => cb(topic, message));
+                self.callbacks.forEach((cb) => cb(topic, message));
             }
         };
     }
     async sayPong(appId, guid, originator, details = false) {
         let profile;
         if (details) {
-            const stream = this.engine.stream.mintKey(hotmesh_1.KeyType.STREAMS, { appId: this.appId });
+            const stream = this.engine.stream.mintKey(hotmesh_1.KeyType.STREAMS, {
+                appId: this.appId,
+            });
             profile = {
                 engine_id: this.guid,
                 namespace: this.namespace,
@@ -119,7 +121,8 @@ class QuorumService {
         }
         this.store.publish(hotmesh_1.KeyType.QUORUM, {
             type: 'pong',
-            guid, originator,
+            guid,
+            originator,
             profile,
         }, appId);
     }
@@ -141,10 +144,10 @@ class QuorumService {
      */
     async doRollCall(message) {
         let iteration = 0;
-        let max = !isNaN(message.max) ? message.max : enums_1.HMSH_QUORUM_ROLLCALL_CYCLES;
+        const max = !isNaN(message.max) ? message.max : enums_1.HMSH_QUORUM_ROLLCALL_CYCLES;
         if (this.rollCallInterval)
             clearTimeout(this.rollCallInterval);
-        const base = (message.interval / 2);
+        const base = message.interval / 2;
         const amount = base + Math.ceil(Math.random() * base);
         do {
             await (0, utils_1.sleepFor)(Math.ceil(Math.random() * 1000));
@@ -178,7 +181,7 @@ class QuorumService {
     //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);
+        this.callbacks = this.callbacks.filter((cb) => cb !== callback);
     }
     // ************* COMPILER METHODS *************
     async rollCall(delay = enums_1.HMSH_QUORUM_DELAY_MS) {
@@ -191,13 +194,13 @@ class QuorumService {
                 this.store.xlen(profile.stream, multi);
             }
         });
-        const stream_depths = await multi.exec();
+        const stream_depths = (await multi.exec());
         this.profiles.forEach(async (profile) => {
             const index = targetStreams.indexOf(profile.stream);
             if (index != -1) {
-                profile.stream_depth = Array.isArray(stream_depths[index]) ?
-                    stream_depths[index][1] :
-                    stream_depths[index];
+                profile.stream_depth = Array.isArray(stream_depths[index])
+                    ? stream_depths[index][1]
+                    : stream_depths[index];
             }
         });
         return this.profiles;
@@ -223,7 +226,7 @@ class QuorumService {
         if (q1 && q1 === q2 && q2 === q3) {
             this.logger.info('quorum-rollcall-succeeded', { q1, q2, q3 });
             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 new Promise((resolve) => setTimeout(resolve, delay));
             await this.store.releaseScoutRole('activate');
             //confirm we received the activation message
             if (this.engine.untilVersion === version) {

package/build/services/reporter/index.js

@@ -21,7 +21,8 @@ class ReporterService {
     }
     validateOptions(options) {
         const { start, end, range, granularity } = options;
-        if (granularity !== 'infinity' && (start && end && range || !start && !end && !range)) {
+        if (granularity !== 'infinity' &&
+            (start && end && range || !start && !end && !range)) {
             throw new Error('Invalid combination of start, end, and range values. Provide either start+end, end+range, or start+range.');
         }
     }
@@ -61,7 +62,8 @@ class ReporterService {
             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);
+        startTime.setUTCMinutes(Math.floor(startTime.getUTCMinutes() / granularityMinutes) *
+            granularityMinutes);
         const dateTimeSets = [];
         for (let time = startTime; time <= endTime; time.setUTCMinutes(time.getUTCMinutes() + granularityMinutes)) {
             const formattedTime = [
@@ -116,7 +118,7 @@ class ReporterService {
     }
     buildStatsResponse(rawData, redisKeys, aggregatedData, count, options) {
         const measures = [];
-        const measureKeys = Object.keys(aggregatedData).filter((key) => key !== "count");
+        const measureKeys = Object.keys(aggregatedData).filter((key) => key !== 'count');
         let segments = undefined;
         if (options.sparse !== true) {
             segments = this.handleSegments(rawData, redisKeys);
@@ -124,7 +126,7 @@ class ReporterService {
         measureKeys.forEach((key) => {
             const measure = {
                 target: key,
-                type: "count",
+                type: 'count',
                 value: aggregatedData[key],
             };
             measures.push(measure);
@@ -146,12 +148,13 @@ class ReporterService {
         const segments = [];
         hashKeys.forEach((hashKey, index) => {
             const segmentData = [];
-            data[hashKey] && Object.entries(data[hashKey]).forEach(([key, value]) => {
-                if (key.startsWith('count:')) {
-                    const target = key.slice('count:'.length);
-                    segmentData.push({ target, type: 'count', value });
-                }
-            });
+            data[hashKey] &&
+                Object.entries(data[hashKey]).forEach(([key, value]) => {
+                    if (key.startsWith('count:')) {
+                        const target = key.slice('count:'.length);
+                        segmentData.push({ target, type: 'count', value });
+                    }
+                });
             const isoTimestamp = this.isoTimestampFromKeyTimestamp(hashKey);
             const count = data[hashKey] ? data[hashKey].count : 0;
             segments.push({ count, time: isoTimestamp, measures: segmentData });
@@ -236,7 +239,7 @@ class ReporterService {
         return segments;
     }
     getUniqueFacets(data) {
-        const targets = data.measures.map(measure => measure.target);
+        const targets = data.measures.map((measure) => measure.target);
         return Array.from(new Set(targets));
     }
     getTargetForKey(key) {
@@ -279,7 +282,7 @@ class ReporterService {
         const stats = {
             general: [],
             index: [],
-            median: []
+            median: [],
         };
         stats.general.push({ metric: 'count', target: 'count', value: 1 });
         for (const measure of statsConfig.measures) {

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

@@ -43,12 +43,12 @@ declare class Router {
     consumeMessages(stream: string, group: string, consumer: string, callback: (streamData: StreamData) => Promise<StreamDataResponse | void>): Promise<void>;
     isStreamMessage(result: any): boolean;
     consumeOne(stream: string, group: string, id: string, message: string[], callback: (streamData: StreamData) => Promise<StreamDataResponse | void>): Promise<void>;
-    execStreamLeg(input: StreamData, stream: string, id: string, callback: (streamData: StreamData) => Promise<StreamDataResponse | void>): Promise<StreamDataResponse>;
+    execStreamLeg(input: StreamData, stream: string, id: string, callback: (streamData: StreamData) => Promise<StreamDataResponse | void>): Promise<StreamData>;
     ackAndDelete(stream: string, group: string, id: string): Promise<void>;
     publishResponse(input: StreamData, output: StreamDataResponse | void): Promise<string>;
     shouldRetry(input: StreamData, output: StreamDataResponse): [boolean, number];
     structureUnhandledError(input: StreamData, err: Error): StreamDataResponse;
-    structureUnacknowledgedError(input: StreamData): StreamDataResponse;
+    structureUnacknowledgedError(input: StreamData): StreamData;
     structureError(input: StreamData, output: StreamDataResponse): StreamDataResponse;
     static stopConsuming(): Promise<void>;
     stopConsuming(): Promise<void>;

package/build/services/router/index.js

@@ -44,7 +44,10 @@ class Router {
     async publishMessage(topic, streamData, multi) {
         const code = streamData?.code || '200';
         this.counts[code] = (this.counts[code] || 0) + 1;
-        const stream = this.store.mintKey(key_1.KeyType.STREAMS, { appId: this.store.appId, topic });
+        const stream = this.store.mintKey(key_1.KeyType.STREAMS, {
+            appId: this.store.appId,
+            topic,
+        });
         return await this.store.xadd(stream, '*', 'message', JSON.stringify(streamData), multi);
     }
     /**
@@ -62,7 +65,7 @@ class Router {
         if (this.isSleeping)
             return;
         this.isSleeping = true;
-        let startTime = Date.now(); //anchor the origin
+        const startTime = Date.now(); //anchor the origin
         await new Promise(async (outerResolve) => {
             this.sleepPromiseResolve = outerResolve;
             let elapsedTime = Date.now() - startTime;
@@ -86,12 +89,16 @@ class Router {
         async function consume() {
             await this.customSleep();
             if (!this.shouldConsume) {
-                this.logger.info(`stream-consumer-stopping`, { group, consumer, stream });
+                this.logger.info(`stream-consumer-stopping`, {
+                    group,
+                    consumer,
+                    stream,
+                });
                 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 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.isStreamMessage(result)) {
                     const [[, messages]] = result;
@@ -112,9 +119,14 @@ class Router {
             }
             catch (err) {
                 if (this.shouldConsume && process.env.NODE_ENV !== 'test') {
-                    this.logger.error(`stream-consume-message-error`, { err, stream, group, consumer });
+                    this.logger.error(`stream-consume-message-error`, {
+                        err,
+                        stream,
+                        group,
+                        consumer,
+                    });
                     this.errorCount++;
-                    const timeout = Math.min(enums_1.HMSH_GRADUATED_INTERVAL_MS * (2 ** this.errorCount), enums_1.HMSH_MAX_TIMEOUT_MS);
+                    const timeout = Math.min(enums_1.HMSH_GRADUATED_INTERVAL_MS * 2 ** this.errorCount, enums_1.HMSH_MAX_TIMEOUT_MS);
                     setTimeout(consume.bind(this), timeout);
                 }
             }
@@ -154,7 +166,15 @@ class Router {
             output = await callback(input);
         }
         catch (error) {
-            this.logger.error(`stream-call-function-error`, { ...error, input: input, stack: error.stack, message: error.message, name: error.name, stream, id });
+            this.logger.error(`stream-call-function-error`, {
+                ...error,
+                input: input,
+                stack: error.stack,
+                message: error.message,
+                name: error.name,
+                stream,
+                id,
+            });
             output = this.structureUnhandledError(input, error);
         }
         return output;
@@ -171,12 +191,12 @@ class Router {
                 const [shouldRetry, timeout] = this.shouldRetry(input, output);
                 if (shouldRetry) {
                     await (0, utils_1.sleepFor)(timeout);
-                    return await this.publishMessage(input.metadata.topic, {
+                    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,
-                    });
+                    }));
                 }
                 else {
                     output = this.structureError(input, output);
@@ -189,7 +209,7 @@ class Router {
                 output.metadata.guid = (0, utils_1.guid)();
             }
             output.type = stream_1.StreamDataType.RESPONSE;
-            return await this.publishMessage(null, output);
+            return (await this.publishMessage(null, output));
         }
     }
     shouldRetry(input, output) {
@@ -208,7 +228,7 @@ class Router {
         return [false, 0];
     }
     structureUnhandledError(input, err) {
-        let error = {};
+        const error = {};
         if (typeof err.message === 'string') {
             error.message = err.message;
         }
@@ -225,7 +245,7 @@ class Router {
             status: 'error',
             code: enums_1.HMSH_CODE_UNKNOWN,
             metadata: { ...input.metadata, guid: (0, utils_1.guid)() },
-            data: error
+            data: error,
         };
     }
     structureUnacknowledgedError(input) {
@@ -243,10 +263,16 @@ class Router {
         return output;
     }
     structureError(input, output) {
-        const message = output.data?.message ? output.data?.message.toString() : enums_1.HMSH_STATUS_UNKNOWN;
+        const message = output.data?.message
+            ? output.data?.message.toString()
+            : enums_1.HMSH_STATUS_UNKNOWN;
         const statusCode = output.code || output.data?.code;
-        const code = isNaN(statusCode) ? enums_1.HMSH_CODE_UNKNOWN : parseInt(statusCode.toString());
-        const stack = output.data?.stack ? output.data?.stack.toString() : undefined;
+        const code = isNaN(statusCode)
+            ? enums_1.HMSH_CODE_UNKNOWN
+            : parseInt(statusCode.toString());
+        const stack = output.data?.stack
+            ? output.data?.stack.toString()
+            : undefined;
         const data = { message, code, stack };
         if (typeof output.data?.error === 'object') {
             data.error = { ...output.data.error };
@@ -256,7 +282,7 @@ class Router {
             code,
             stack,
             metadata: { ...input.metadata, guid: (0, utils_1.guid)() },
-            data
+            data,
         };
     }
     static async stopConsuming() {
@@ -321,15 +347,27 @@ class Router {
         //     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, group, consumer, code: enums_1.HMSH_CODE_UNACKED, count });
+        this.logger.error('stream-message-max-delivery-count-exceeded', {
+            id,
+            stream,
+            group,
+            consumer,
+            code: enums_1.HMSH_CODE_UNACKED,
+            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', { id, err });
+            return this.logger.error('expire-unacknowledged-parse-fatal-error', {
+                id,
+                err,
+            });
         }
         else if (!input || !input.metadata) {
-            return this.logger.error('expire-unacknowledged-parse-fatal-error', { id });
+            return this.logger.error('expire-unacknowledged-parse-fatal-error', {
+                id,
+            });
         }
         let telemetry;
         let messageId;
@@ -346,12 +384,24 @@ class Router {
         }
         catch (err) {
             if (messageId) {
-                this.logger.error('expire-unacknowledged-pub-fatal-error', { id, err, ...input.metadata });
-                telemetry.setStreamAttributes({ 'app.system.fatal': 'expire-unacknowledged-pub-fatal-error' });
+                this.logger.error('expire-unacknowledged-pub-fatal-error', {
+                    id,
+                    err,
+                    ...input.metadata,
+                });
+                telemetry.setStreamAttributes({
+                    'app.system.fatal': 'expire-unacknowledged-pub-fatal-error',
+                });
             }
             else {
-                this.logger.error('expire-unacknowledged-ack-fatal-error', { id, err, ...input.metadata });
-                telemetry.setStreamAttributes({ 'app.system.fatal': 'expire-unacknowledged-ack-fatal-error' });
+                this.logger.error('expire-unacknowledged-ack-fatal-error', {
+                    id,
+                    err,
+                    ...input.metadata,
+                });
+                telemetry.setStreamAttributes({
+                    'app.system.fatal': 'expire-unacknowledged-ack-fatal-error',
+                });
             }
         }
         finally {

package/build/services/serializer/index.js

@@ -6,17 +6,37 @@ const dateReg = /^"\d{4}-\d{2}-\d{2}(?:T\d{2}:\d{2}:\d{2}(?:\.\d{3})?Z)?"$/;
 exports.MDATA_SYMBOLS = {
     SLOTS: 26,
     ACTIVITY: {
-        KEYS: ['aid', 'dad', 'as', 'atp', 'stp', 'ac', 'au', 'err', 'l1s', 'l2s']
+        KEYS: ['aid', 'dad', 'as', 'atp', 'stp', 'ac', 'au', 'err', 'l1s', 'l2s'],
     },
     ACTIVITY_UPDATE: {
-        KEYS: ['au', 'err', 'l2s']
+        KEYS: ['au', 'err', 'l2s'],
     },
     JOB: {
-        KEYS: ['ngn', 'tpc', 'pj', 'pg', 'pd', 'px', 'pa', 'key', 'app', 'vrs', 'jid', 'gid', 'aid', 'ts', 'jc', 'ju', 'js', 'err', 'trc']
+        KEYS: [
+            'ngn',
+            'tpc',
+            'pj',
+            'pg',
+            'pd',
+            'px',
+            'pa',
+            'key',
+            'app',
+            'vrs',
+            'jid',
+            'gid',
+            'aid',
+            'ts',
+            'jc',
+            'ju',
+            'js',
+            'err',
+            'trc',
+        ],
     },
     JOB_UPDATE: {
-        KEYS: ['ju', 'err']
-    }
+        KEYS: ['ju', 'err'],
+    },
 };
 class SerializerService {
     constructor() {
@@ -72,7 +92,7 @@ class SerializerService {
         let map = this.symReverseKeys.get(id);
         if (!map) {
             map = new Map();
-            for (let [key, val] of keyMap.entries()) {
+            for (const [key, val] of keyMap.entries()) {
                 map.set(val, key);
             }
             this.symReverseKeys.set(id, map);
@@ -81,16 +101,16 @@ class SerializerService {
     }
     getReverseValueMap(valueMap) {
         const map = new Map();
-        for (let [key, val] of valueMap.entries()) {
+        for (const [key, val] of valueMap.entries()) {
             map.set(val, key);
         }
         return map;
     }
     static filterSymVals(startIndex, maxIndex, existingSymbolValues, proposedValues) {
-        let newSymbolValues = {};
-        let currentSymbolValues = { ...existingSymbolValues };
-        let currentValuesSet = new Set(Object.values(currentSymbolValues));
-        for (let value of proposedValues) {
+        const newSymbolValues = {};
+        const currentSymbolValues = { ...existingSymbolValues };
+        const currentValuesSet = new Set(Object.values(currentSymbolValues));
+        for (const value of proposedValues) {
             if (!currentValuesSet.has(value)) {
                 if (startIndex > maxIndex) {
                     return newSymbolValues;
@@ -107,13 +127,15 @@ class SerializerService {
         if (this.symKeys.size === 0) {
             return document;
         }
-        let source = { ...document };
-        let result = {};
+        const source = { ...document };
+        const result = {};
         const compressWithMap = (abbreviationMap, id) => {
-            for (let key in source) {
-                if (key.startsWith(`${id}/`) || (id.startsWith('$') && ['data', 'metadata'].includes(key.split('/')[0]))) {
+            for (const key in source) {
+                if (key.startsWith(`${id}/`) ||
+                    id.startsWith('$') &&
+                        ['data', 'metadata'].includes(key.split('/')[0])) {
                     const dimensionalIndex = this.resolveDimensionalIndex(key);
-                    let shortKey = abbreviationMap.get(key) || key;
+                    const shortKey = abbreviationMap.get(key) || key;
                     const shortDimensionalKey = `${shortKey}${dimensionalIndex}`;
                     result[shortDimensionalKey] = source[key];
                 }
@@ -123,7 +145,7 @@ class SerializerService {
                 }
             }
         };
-        for (let id of ids) {
+        for (const id of ids) {
             const abbreviationMap = this.symKeys.get(id);
             if (abbreviationMap) {
                 compressWithMap(abbreviationMap, id);
@@ -138,20 +160,20 @@ class SerializerService {
         if (this.symKeys.size === 0) {
             return document;
         }
-        let result = { ...document };
+        const result = { ...document };
         const inflateWithMap = (abbreviationMap, id) => {
             const reversedAbbreviationMap = this.getReverseKeyMap(abbreviationMap, id);
-            for (let key in result) {
+            for (const key in result) {
                 //strip dimensional index from key
                 const shortKey = key.split(',')[0];
-                let longKey = reversedAbbreviationMap.get(shortKey);
+                const longKey = reversedAbbreviationMap.get(shortKey);
                 if (longKey) {
                     result[longKey] = result[key];
                     delete result[key];
                 }
             }
         };
-        for (let id of ids) {
+        for (const id of ids) {
             const abbreviationMap = this.symKeys.get(id);
             if (abbreviationMap) {
                 inflateWithMap(abbreviationMap, id);
@@ -161,9 +183,9 @@ class SerializerService {
     }
     //stringify: convert a multi-dimensional document to a 2-d hash
     stringify(document) {
-        let result = {};
-        for (let key in document) {
-            let value = SerializerService.toString(document[key]);
+        const result = {};
+        for (const key in document) {
+            const value = SerializerService.toString(document[key]);
             if (value) {
                 // if (/^:*[a-zA-Z]{2}$/.test(value)) {
                 //   value = ':' + value;
@@ -177,8 +199,8 @@ class SerializerService {
     }
     //parse: convert a 2-d hash to a multi-dimensional document
     parse(document) {
-        let result = {};
-        for (let [key, value] of Object.entries(document)) {
+        const result = {};
+        for (const [key, value] of Object.entries(document)) {
             if (value === undefined || value === null)
                 continue;
             // if (/^:+[a-zA-Z]{2}$/.test(value)) {

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

@@ -5,11 +5,11 @@
  * (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";
-import { Symbols } from "../../types/serializer";
-import { Transitions } from "../../types/transition";
+import { ActivityType } from '../../types/activity';
+import { HookRule } from '../../types/hook';
+import { HotMeshApp, HotMeshSettings } from '../../types/hotmesh';
+import { Symbols } from '../../types/serializer';
+import { Transitions } from '../../types/transition';
 declare class Cache {
     settings: HotMeshSettings;
     appId: string;

package/build/services/store/cache.js

@@ -110,10 +110,10 @@ class Cache {
         this.hookRules[`${appId}`] = hookRules;
     }
     getSignals(appId, version) {
-        throw new Error("SIGNAL (getHooks) is not supported");
+        throw new Error('SIGNAL (getHooks) is not supported');
     }
     setSignals(appId, version) {
-        throw new Error("SIGNAL (setHook) is not supported");
+        throw new Error('SIGNAL (setHook) is not supported');
     }
     getActiveTaskQueue(appId) {
         return this.workItems[appId];

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

@@ -13,6 +13,12 @@ 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.
+     * All other commands are sent simultaneously
+     * using Promise.all and are then collated
+     */
     getMulti(): RedisMultiType;
     exec(...args: any[]): Promise<string | string[] | string[][]>;
     hGetAllResult(result: any): any;