@hotmeshio/hotmesh 0.0.3 → 0.0.5

package/build/{services → cjs/services}/serializer/index.js

@@ -20,9 +20,45 @@ exports.MDATA_SYMBOLS = {
 };
 class SerializerService {
     constructor() {
-        this.resetSymbols({}, {});
+        this.resetSymbols({}, {}, {});
     }
-    resetSymbols(symKeys, symVals) {
+    abbreviate(consumes, symbolNames, fields = []) {
+        for (const symbolName of symbolNames) {
+            const symbolSet = this.symKeys.get(symbolName);
+            const symbolPaths = consumes[symbolName];
+            for (const symbolPath of symbolPaths) {
+                const abbreviation = symbolSet.get(symbolPath);
+                if (abbreviation) {
+                    const dimensionalIndex = this.resolveDimensionalIndex(symbolPath);
+                    fields.push(`${abbreviation}${dimensionalIndex}`);
+                }
+                else {
+                    fields.push(symbolPath);
+                }
+            }
+        }
+        return fields;
+    }
+    resolveDimensionalIndex(path) {
+        if (this.isJobPath(path)) {
+            return '';
+        }
+        else {
+            const [activityId] = path.split('/');
+            if (activityId in this.dIds) {
+                return this.dIds[activityId];
+            }
+            else if ('$ADJACENT' in this.dIds) {
+                //else=> pre-authorizing adjacent activity entry
+                return this.dIds['$ADJACENT'];
+            }
+            return ',0';
+        }
+    }
+    isJobPath(path) {
+        return path.startsWith('data/') || path.startsWith('metadata/');
+    }
+    resetSymbols(symKeys, symVals, dIds) {
         this.symKeys = new Map();
         this.symReverseKeys = new Map();
         for (const id in symKeys) {
@@ -30,6 +66,7 @@ class SerializerService {
         }
         this.symValMaps = new Map(Object.entries(symVals));
         this.symValReverseMaps = this.getReverseValueMap(this.symValMaps);
+        this.dIds = dIds;
     }
     getReverseKeyMap(keyMap, id) {
         let map = this.symReverseKeys.get(id);
@@ -70,24 +107,22 @@ class SerializerService {
         if (this.symKeys.size === 0) {
             return document;
         }
-        let result = { ...document };
-        const compressWithMap = (abbreviationMap) => {
-            for (let key in result) {
-                let safeKey = abbreviationMap.get(key) || key;
-                let value = result[key];
-                let safeValue = abbreviationMap.get(value) || value;
-                if (safeKey !== key || safeValue !== value) {
-                    result[safeKey] = safeValue;
-                    if (safeKey !== key) {
-                        delete result[key];
-                    }
+        let source = { ...document };
+        let result = {};
+        const compressWithMap = (abbreviationMap, id) => {
+            for (let 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 shortDimensionalKey = `${shortKey}${dimensionalIndex}`;
+                    result[shortDimensionalKey] = source[key];
                 }
             }
         };
         for (let id of ids) {
             const abbreviationMap = this.symKeys.get(id);
             if (abbreviationMap) {
-                compressWithMap(abbreviationMap);
+                compressWithMap(abbreviationMap, id);
             }
         }
         return result;
@@ -100,14 +135,12 @@ class SerializerService {
         const inflateWithMap = (abbreviationMap, id) => {
             const reversedAbbreviationMap = this.getReverseKeyMap(abbreviationMap, id);
             for (let key in result) {
-                let safeKey = reversedAbbreviationMap.get(key) || key;
-                let value = result[key];
-                let safeValue = reversedAbbreviationMap.get(value) || value;
-                if (safeKey !== key || safeValue !== value) {
-                    result[safeKey] = safeValue;
-                    if (safeKey !== key) {
-                        delete result[key];
-                    }
+                //strip dimensional index from key
+                const shortKey = key.split(',')[0];
+                let longKey = reversedAbbreviationMap.get(shortKey);
+                if (longKey) {
+                    result[longKey] = result[key];
+                    delete result[key];
                 }
             }
         };

package/build/{services → cjs/services}/signaler/stream.js

@@ -121,6 +121,7 @@ class StreamSignaler {
             output = await callback(input);
         }
         catch (err) {
+            console.error(err);
             this.logger.error(`stream-call-function-error`, { stream, id, err });
             output = this.structureUnhandledError(input, err);
         }

package/build/{services → cjs/services}/store/index.d.ts

@@ -59,9 +59,9 @@ declare abstract class StoreService<T, U extends AbstractRedisClient> {
     getJobIds(indexKeys: string[], idRange: [number, number]): Promise<IdsData>;
     setStatus(collationKeyStatus: number, jobId: string, appId: string, multi?: U): Promise<any>;
     getStatus(jobId: string, appId: string): Promise<number>;
-    setState({ ...state }: StringAnyType, status: number | null, jobId: string, appId: string, symbolNames: string[], multi?: U): Promise<string>;
-    getState(jobId: string, consumes: Consumes): Promise<[StringAnyType, number] | undefined>;
-    collate(jobId: string, activityId: string, amount: number, multi?: U): Promise<number>;
+    setState({ ...state }: StringAnyType, status: number | null, jobId: string, symbolNames: string[], dIds: StringStringType, multi?: U): Promise<string>;
+    getState(jobId: string, consumes: Consumes, dIds: StringStringType): Promise<[StringAnyType, number] | undefined>;
+    collate(jobId: string, activityId: string, amount: number, dIds: StringStringType, multi?: U): Promise<number>;
     setStateNX(jobId: string, appId: string): Promise<boolean>;
     getSchema(activityId: string, appVersion: AppVID): Promise<ActivityType>;
     getSchemas(appVersion: AppVID): Promise<Record<string, ActivityType>>;

package/build/{services → cjs/services}/store/index.js

@@ -110,7 +110,7 @@ class StoreService {
         else {
             if (bCreate) {
                 const packageJson = await Promise.resolve().then(() => __importStar(require('../../package.json')));
-                const version = packageJson.version;
+                const version = packageJson['version'] || '0.0.0';
                 settings = { namespace: key_1.PSNS, version };
                 await this.setSettings(settings);
                 return settings;
@@ -374,12 +374,12 @@ class StoreService {
         const status = await this.redisClient[this.commands.hget](jobKey, ':');
         return Number(status);
     }
-    async setState({ ...state }, status, jobId, appId, symbolNames, multi) {
+    async setState({ ...state }, status, jobId, symbolNames, dIds, multi) {
         delete state['metadata/js'];
-        const hashKey = this.mintKey(key_1.KeyType.JOB_STATE, { appId, jobId });
+        const hashKey = this.mintKey(key_1.KeyType.JOB_STATE, { appId: this.appId, jobId });
         const symKeys = await this.getSymbolKeys(symbolNames);
         const symVals = await this.getSymbolValues();
-        this.serializer.resetSymbols(symKeys, symVals);
+        this.serializer.resetSymbols(symKeys, symVals, dIds);
         const hashData = this.serializer.package(state, symbolNames);
         if (status !== null) {
             hashData[':'] = status.toString();
@@ -390,26 +390,13 @@ class StoreService {
         await (multi || this.redisClient)[this.commands.hset](hashKey, hashData);
         return jobId;
     }
-    async getState(jobId, consumes) {
-        //todo: refactor into semantic submethods
+    async getState(jobId, consumes, dIds) {
+        //get abbreviated field list (the symbols for the paths)
         const key = this.mintKey(key_1.KeyType.JOB_STATE, { appId: this.appId, jobId });
         const symbolNames = Object.keys(consumes);
         const symKeys = await this.getSymbolKeys(symbolNames);
-        //always fetch the job status (':') when fetching state
-        const fields = [':'];
-        for (const symbolName of symbolNames) {
-            const symbolSet = symKeys[symbolName];
-            const symbolPaths = consumes[symbolName];
-            for (const symbolPath of symbolPaths) {
-                const abbreviation = symbolSet[symbolPath];
-                if (abbreviation) {
-                    fields.push(abbreviation);
-                }
-                else {
-                    fields.push(symbolPath);
-                }
-            }
-        }
+        this.serializer.resetSymbols(symKeys, {}, dIds);
+        const fields = this.serializer.abbreviate(consumes, symbolNames, [':']);
         const jobDataArray = await this.redisClient[this.commands.hmget](key, fields);
         const jobData = {};
         let atLeast1 = false; //if status field (':') isn't present assume 404
@@ -421,7 +408,7 @@ class StoreService {
         });
         if (atLeast1) {
             const symVals = await this.getSymbolValues();
-            this.serializer.resetSymbols(symKeys, symVals);
+            this.serializer.resetSymbols(symKeys, symVals, dIds);
             const state = this.serializer.unpackage(jobData, symbolNames);
             let status = 0;
             if (state[':']) {
@@ -432,13 +419,13 @@ class StoreService {
             return [state, status];
         }
     }
-    async collate(jobId, activityId, amount, multi) {
+    async collate(jobId, activityId, amount, dIds, multi) {
         const jobKey = this.mintKey(key_1.KeyType.JOB_STATE, { appId: this.appId, jobId });
         const collationKey = `${activityId}/output/metadata/as`; //activity state
         const symbolNames = [activityId];
         const symKeys = await this.getSymbolKeys(symbolNames);
         const symVals = await this.getSymbolValues();
-        this.serializer.resetSymbols(symKeys, symVals);
+        this.serializer.resetSymbols(symKeys, symVals, dIds);
         const payload = { [collationKey]: amount.toString() };
         const hashData = this.serializer.package(payload, symbolNames);
         const targetId = Object.keys(hashData)[0];

package/build/{types → cjs/types}/activity.d.ts

@@ -23,6 +23,7 @@ interface BaseActivity {
     subscribes?: string;
     trigger?: string;
     parent?: string;
+    ancestors?: string[];
 }
 interface Measure {
     measure: MetricTypes;

package/build/esm/index.d.ts

@@ -0,0 +1,4 @@
+import { Durable } from './services/durable';
+import { HotMeshService as HotMesh } from './services/hotmesh';
+import { HotMeshConfig } from './types/hotmesh';
+export { Durable, HotMesh, HotMeshConfig };

package/build/esm/index.js

@@ -0,0 +1,3 @@
+import { Durable } from './services/durable';
+import { HotMeshService as HotMesh } from './services/hotmesh';
+export { Durable, HotMesh };

package/build/esm/modules/errors.d.ts

@@ -0,0 +1,28 @@
+import { ActivityDuplex } from "../types/activity";
+import { CollationFaultType, CollationStage } from "../types/collator";
+declare class GetStateError extends Error {
+    constructor();
+}
+declare class SetStateError extends Error {
+    constructor();
+}
+declare class MapDataError extends Error {
+    constructor();
+}
+declare class RegisterTimeoutError extends Error {
+    constructor();
+}
+declare class DuplicateJobError extends Error {
+    constructor(jobId: string);
+}
+declare class ExecActivityError extends Error {
+    constructor();
+}
+declare class CollationError extends Error {
+    status: number;
+    leg: ActivityDuplex;
+    stage: CollationStage;
+    fault: CollationFaultType;
+    constructor(status: number, leg: ActivityDuplex, stage: CollationStage, fault?: CollationFaultType);
+}
+export { CollationError, DuplicateJobError, GetStateError, SetStateError, MapDataError, RegisterTimeoutError, ExecActivityError };

package/build/esm/modules/errors.js

@@ -0,0 +1,41 @@
+class GetStateError extends Error {
+    constructor() {
+        super("Error occurred while getting job state");
+    }
+}
+class SetStateError extends Error {
+    constructor() {
+        super("Error occurred while setting job state");
+    }
+}
+class MapDataError extends Error {
+    constructor() {
+        super("Error occurred while mapping data");
+    }
+}
+class RegisterTimeoutError extends Error {
+    constructor() {
+        super("Error occurred while registering activity timeout");
+    }
+}
+class DuplicateJobError extends Error {
+    constructor(jobId) {
+        super("Duplicate job");
+        this.message = `Duplicate job: ${jobId}`;
+    }
+}
+class ExecActivityError extends Error {
+    constructor() {
+        super("Error occurred while executing activity");
+    }
+}
+class CollationError extends Error {
+    constructor(status, leg, stage, fault) {
+        super("collation-error");
+        this.leg = leg;
+        this.status = status;
+        this.stage = stage;
+        this.fault = fault;
+    }
+}
+export { CollationError, DuplicateJobError, GetStateError, SetStateError, MapDataError, RegisterTimeoutError, ExecActivityError };

package/build/esm/modules/key.d.ts

@@ -0,0 +1,75 @@
+/**
+ * Keys
+ *
+ * hmsh ->                                            {hash}    hotmesh config {version: "0.0.1", namespace: "hmsh"}
+ * hmsh:a:<appid> ->                                  {hash}    app profile { "id": "appid", "version": "2", "versions/1": "GMT", "versions/2": "GMT"}
+ * hmsh:<appid>:e:<engineId> ->                       {string}  setnx to ensure only one engine of given id
+ * hmsh:<appid>:w: ->                                 {zset}    work items/tasks an engine must do like garbage collect or hook a set of matching records (hookAll)
+ * hmsh:<appid>:t: ->                                 {zset}    an ordered set of list (work lists) ids
+ * hmsh:<appid>:t:<timeValue?> ->                     {list}    a worklist of `jobId+activityId` items that should be awakened
+ * hmsh:<appid>:q: ->                                 {hash}    quorum-wide messages
+ * hmsh:<appid>:q:<ngnid> ->                          {hash}    engine-targeted messages (targeted quorum-oriented message)
+ * hmsh:<appid>:j:<jobid> ->                          {hash}    job data
+ * hmsh:<appid>:j:<jobid>:<activityid>  ->            {hash}    job activity data (a1)
+ * hmsh:<appid>:s:<jobkey>:<dateTime> ->              {hash}    job stats (general)
+ * hmsh:<appid>:s:<jobkey>:<dateTime>:mdn:<field/path>:<fieldvalue> ->      {zset}    job stats (median)
+ * hmsh:<appid>:s:<jobkey>:<dateTime>:index:<field/path>:<fieldvalue> ->    {list}    job stats (index of jobid[])
+ * hmsh:<appid>:v:<version>:activities ->             {hash}    schemas [cache]
+ * hmsh:<appid>:v:<version>:transitions ->            {hash}    transitions [cache]
+ * hmsh:<appid>:v:<version>:subscriptions ->          {hash}    subscriptions [cache]
+ * hmsh:<appid>:x: ->                                 {xstream} when an engine is sent or reads a buffered task (engines read from their custom topic)
+ * hmsh:<appid>:x:<topic> ->                          {xstream} when a worker is sent or reads a buffered task (workers read from their custom topic)
+ * hmsh:<appid>:hooks ->                              {hash}    hook patterns/rules; set at compile time
+ * hmsh:<appid>:signals ->                            {hash}    dynamic hook signals (hget/hdel) when resolving (always self-clean); added/removed at runtime
+ * hmsh:<appid>:sym:keys: ->                          {hash}    list of symbol ranges and :cursor assigned at version deploy time for job keys
+ * hmsh:<appid>:sym:keys:<activityid|$subscribes> ->  {hash}    list of symbols based upon schema enums (initially) and adaptively optimized (later) during runtime; if '$subscribes' is used as the activityid, it is a top-level `job` symbol set (for job keys)
+ * hmsh:<appid>:sym:vals: ->                          {hash}    list of symbols for job values across all app versions
+ */
+declare const PSNS = "hmsh";
+declare enum KeyType {
+    APP = 0,
+    ENGINE_ID = 1,
+    HOOKS = 2,
+    JOB_STATE = 3,
+    JOB_STATS_GENERAL = 4,
+    JOB_STATS_MEDIAN = 5,
+    JOB_STATS_INDEX = 6,
+    HOTMESH = 7,
+    QUORUM = 8,
+    SCHEMAS = 9,
+    SIGNALS = 10,
+    STREAMS = 11,
+    SUBSCRIPTIONS = 12,
+    SUBSCRIPTION_PATTERNS = 13,
+    SYMKEYS = 14,
+    SYMVALS = 15,
+    TIME_RANGE = 16,
+    WORK_ITEMS = 17
+}
+type KeyStoreParams = {
+    appId?: string;
+    engineId?: string;
+    appVersion?: string;
+    jobId?: string;
+    activityId?: string;
+    jobKey?: string;
+    dateTime?: string;
+    facet?: string;
+    topic?: string;
+    timeValue?: number;
+};
+declare class KeyService {
+    /**
+     * returns a key that can be used to access a value in the key/value store
+     * appropriate for the given key type; the keys have an implicit hierarchy
+     * and are used to organize data in the store in a tree-like structure
+     * via the use of colons as separators. The top-level entity is the hmsh manifest.
+     * This file will reveal the full scope of what is on the server (apps, versions, etc)
+     * @param namespace
+     * @param keyType
+     * @param params
+     * @returns {string}
+     */
+    static mintKey(namespace: string, keyType: KeyType, params: KeyStoreParams): string;
+}
+export { KeyService, KeyType, KeyStoreParams, PSNS };

package/build/esm/modules/key.js

@@ -0,0 +1,111 @@
+/**
+ * Keys
+ *
+ * hmsh ->                                            {hash}    hotmesh config {version: "0.0.1", namespace: "hmsh"}
+ * hmsh:a:<appid> ->                                  {hash}    app profile { "id": "appid", "version": "2", "versions/1": "GMT", "versions/2": "GMT"}
+ * hmsh:<appid>:e:<engineId> ->                       {string}  setnx to ensure only one engine of given id
+ * hmsh:<appid>:w: ->                                 {zset}    work items/tasks an engine must do like garbage collect or hook a set of matching records (hookAll)
+ * hmsh:<appid>:t: ->                                 {zset}    an ordered set of list (work lists) ids
+ * hmsh:<appid>:t:<timeValue?> ->                     {list}    a worklist of `jobId+activityId` items that should be awakened
+ * hmsh:<appid>:q: ->                                 {hash}    quorum-wide messages
+ * hmsh:<appid>:q:<ngnid> ->                          {hash}    engine-targeted messages (targeted quorum-oriented message)
+ * hmsh:<appid>:j:<jobid> ->                          {hash}    job data
+ * hmsh:<appid>:j:<jobid>:<activityid>  ->            {hash}    job activity data (a1)
+ * hmsh:<appid>:s:<jobkey>:<dateTime> ->              {hash}    job stats (general)
+ * hmsh:<appid>:s:<jobkey>:<dateTime>:mdn:<field/path>:<fieldvalue> ->      {zset}    job stats (median)
+ * hmsh:<appid>:s:<jobkey>:<dateTime>:index:<field/path>:<fieldvalue> ->    {list}    job stats (index of jobid[])
+ * hmsh:<appid>:v:<version>:activities ->             {hash}    schemas [cache]
+ * hmsh:<appid>:v:<version>:transitions ->            {hash}    transitions [cache]
+ * hmsh:<appid>:v:<version>:subscriptions ->          {hash}    subscriptions [cache]
+ * hmsh:<appid>:x: ->                                 {xstream} when an engine is sent or reads a buffered task (engines read from their custom topic)
+ * hmsh:<appid>:x:<topic> ->                          {xstream} when a worker is sent or reads a buffered task (workers read from their custom topic)
+ * hmsh:<appid>:hooks ->                              {hash}    hook patterns/rules; set at compile time
+ * hmsh:<appid>:signals ->                            {hash}    dynamic hook signals (hget/hdel) when resolving (always self-clean); added/removed at runtime
+ * hmsh:<appid>:sym:keys: ->                          {hash}    list of symbol ranges and :cursor assigned at version deploy time for job keys
+ * hmsh:<appid>:sym:keys:<activityid|$subscribes> ->  {hash}    list of symbols based upon schema enums (initially) and adaptively optimized (later) during runtime; if '$subscribes' is used as the activityid, it is a top-level `job` symbol set (for job keys)
+ * hmsh:<appid>:sym:vals: ->                          {hash}    list of symbols for job values across all app versions
+ */
+//default namespace for hotmesh
+const PSNS = "hmsh";
+//these are the entity types that are stored in the key/value store
+var KeyType;
+(function (KeyType) {
+    KeyType[KeyType["APP"] = 0] = "APP";
+    KeyType[KeyType["ENGINE_ID"] = 1] = "ENGINE_ID";
+    KeyType[KeyType["HOOKS"] = 2] = "HOOKS";
+    KeyType[KeyType["JOB_STATE"] = 3] = "JOB_STATE";
+    KeyType[KeyType["JOB_STATS_GENERAL"] = 4] = "JOB_STATS_GENERAL";
+    KeyType[KeyType["JOB_STATS_MEDIAN"] = 5] = "JOB_STATS_MEDIAN";
+    KeyType[KeyType["JOB_STATS_INDEX"] = 6] = "JOB_STATS_INDEX";
+    KeyType[KeyType["HOTMESH"] = 7] = "HOTMESH";
+    KeyType[KeyType["QUORUM"] = 8] = "QUORUM";
+    KeyType[KeyType["SCHEMAS"] = 9] = "SCHEMAS";
+    KeyType[KeyType["SIGNALS"] = 10] = "SIGNALS";
+    KeyType[KeyType["STREAMS"] = 11] = "STREAMS";
+    KeyType[KeyType["SUBSCRIPTIONS"] = 12] = "SUBSCRIPTIONS";
+    KeyType[KeyType["SUBSCRIPTION_PATTERNS"] = 13] = "SUBSCRIPTION_PATTERNS";
+    KeyType[KeyType["SYMKEYS"] = 14] = "SYMKEYS";
+    KeyType[KeyType["SYMVALS"] = 15] = "SYMVALS";
+    KeyType[KeyType["TIME_RANGE"] = 16] = "TIME_RANGE";
+    KeyType[KeyType["WORK_ITEMS"] = 17] = "WORK_ITEMS";
+})(KeyType || (KeyType = {}));
+class KeyService {
+    /**
+     * returns a key that can be used to access a value in the key/value store
+     * appropriate for the given key type; the keys have an implicit hierarchy
+     * and are used to organize data in the store in a tree-like structure
+     * via the use of colons as separators. The top-level entity is the hmsh manifest.
+     * This file will reveal the full scope of what is on the server (apps, versions, etc)
+     * @param namespace
+     * @param keyType
+     * @param params
+     * @returns {string}
+     */
+    static mintKey(namespace, keyType, params) {
+        switch (keyType) {
+            case KeyType.HOTMESH:
+                return namespace;
+            case KeyType.ENGINE_ID:
+                return `${namespace}:${params.appId}:e:${params.engineId}`;
+            case KeyType.WORK_ITEMS:
+                return `${namespace}:${params.appId}:w:`;
+            case KeyType.TIME_RANGE:
+                return `${namespace}:${params.appId}:t:${params.timeValue || ''}`;
+            case KeyType.APP:
+                return `${namespace}:a:${params.appId || ''}`;
+            case KeyType.QUORUM:
+                return `${namespace}:${params.appId}:q:${params.engineId || ''}`;
+            case KeyType.JOB_STATE:
+                return `${namespace}:${params.appId}:j:${params.jobId}`;
+            case KeyType.JOB_STATS_GENERAL:
+                return `${namespace}:${params.appId}:s:${params.jobKey}:${params.dateTime}`;
+            case KeyType.JOB_STATS_MEDIAN:
+                return `${namespace}:${params.appId}:s:${params.jobKey}:${params.dateTime}:${params.facet}`;
+            case KeyType.JOB_STATS_INDEX:
+                return `${namespace}:${params.appId}:s:${params.jobKey}:${params.dateTime}:${params.facet}`;
+            case KeyType.SCHEMAS:
+                return `${namespace}:${params.appId}:v:${params.appVersion}:schemas`;
+            case KeyType.SUBSCRIPTIONS:
+                return `${namespace}:${params.appId}:v:${params.appVersion}:subscriptions`;
+            case KeyType.SUBSCRIPTION_PATTERNS:
+                return `${namespace}:${params.appId}:v:${params.appVersion}:transitions`;
+            case KeyType.HOOKS:
+                //`hooks` provide the pattern to resolve a value
+                return `${namespace}:${params.appId}:hooks`;
+            case KeyType.SIGNALS:
+                //`signals` provide the registry of resolved values that link back to paused jobs
+                return `${namespace}:${params.appId}:signals`;
+            case KeyType.SYMKEYS:
+                //`symbol keys` provide the registry of replacement values for job keys
+                return `${namespace}:${params.appId}:sym:keys:${params.activityId || ''}`;
+            case KeyType.SYMVALS:
+                //`symbol vals` provide the registry of replacement values for job vals
+                return `${namespace}:${params.appId}:sym:vals:`;
+            case KeyType.STREAMS:
+                return `${namespace}:${params.appId || ''}:x:${params.topic || ''}`;
+            default:
+                throw new Error("Invalid key type.");
+        }
+    }
+}
+export { KeyService, KeyType, PSNS };

package/build/esm/modules/utils.d.ts

@@ -0,0 +1,34 @@
+/// <reference types="node" />
+import { StoreService } from "../services/store";
+import { AppSubscriptions, AppTransitions, AppVID } from "../types/app";
+import { RedisClient, RedisMulti } from "../types/redis";
+import { StringAnyType } from "../types/serializer";
+import { StreamCode, StreamStatus } from "../types/stream";
+export declare function sleepFor(ms: number): Promise<unknown>;
+export declare function identifyRedisType(redisInstance: any): 'redis' | 'ioredis' | null;
+export declare function identifyRedisTypeFromClass(redisClass: any): 'redis' | 'ioredis' | null;
+export declare function matchesStatusCode(code: StreamCode, pattern: string | RegExp): boolean;
+export declare function matchesStatus(status: StreamStatus, targetStatus: StreamStatus): boolean;
+export declare function XSleepFor(ms: number): {
+    promise: Promise<unknown>;
+    timerId: NodeJS.Timeout;
+};
+export declare function findTopKey(obj: AppTransitions, input: string): string | null;
+export declare function findSubscriptionForTrigger(obj: AppSubscriptions, value: string): string | null;
+/**
+ * Get the subscription topic for the flow to which @activityId belongs.
+ * TODO: resolve this value in the compiler...do not call this at runtime
+ */
+export declare function getSubscriptionTopic(activityId: string, store: StoreService<RedisClient, RedisMulti>, appVID: AppVID): Promise<string | undefined>;
+/**
+ * returns the 12-digit format of the iso timestamp (e.g, 202101010000)
+ */
+export declare function getTimeSeries(granularity: string): string;
+export declare function formatISODate(input: Date | string): string;
+export declare function getSymKey(number: number): string;
+export declare function getSymVal(number: number): string;
+export declare function getIndexedHash<T>(hash: T, target: string): [number, T];
+export declare function getValueByPath(obj: {
+    [key: string]: any;
+}, path: string): any;
+export declare function restoreHierarchy(obj: StringAnyType): StringAnyType;