@hotmeshio/hotmesh 0.0.4 → 0.0.5

package/README.md

@@ -66,7 +66,7 @@ run().catch((err) => {
 ```javascript
 import { Durable } from '@hotmeshio/hotmesh';
 import Redis from 'ioredis';
-import { nanoid } from 'nanoid';
+import { v4 as uuidv4 } from 'uuid';
 
 async function run() {
   const connection = await Durable.Connection.connect({
@@ -85,7 +85,7 @@ async function run() {
     args: ['HotMesh'],
     taskQueue: 'hello-world',
     workflowName: 'example',
-    workflowId: 'workflow-' + nanoid(),
+    workflowId: 'workflow-' + uuidv4(),
   });
 
   console.log(`Started workflow ${handle.workflowId}`);

package/build/{package.json → cjs/package.json}

@@ -1,9 +1,14 @@
 {
     "name": "@hotmeshio/hotmesh",
-    "version": "0.0.4",
+    "version": "0.0.5",
     "description": "Durable Workflows",
-    "main": "build/index.js",
-    "types": "build/index.d.ts",
+    "main": "build/cjs/index.js",
+    "module": "build/esm/index.js",
+    "types": "build/cjs/index.d.ts",
+    "exports": {
+        "import": "./build/esm/index.js",
+        "require": "./build/cjs/index.js"
+    },
     "repository": {
         "type": "git",
         "url": "https://github.com/hotmeshio/sdk-typescript.git"
@@ -14,7 +19,9 @@
     },
     "scripts": {
         "clean": "rimraf ./build",
-        "build": "tsc --build tsconfig.json",
+        "build:cjs": "tsc --build tsconfig.cjs.json",
+        "build:esm": "tsc --build tsconfig.esm.json",
+        "build": "npm run build:cjs && npm run build:esm",
         "clean-build": "npm run clean && npm run build",
         "lint": "eslint . --ext .ts",
         "lint:fix": "eslint . --fix --ext .ts",
@@ -52,7 +59,7 @@
         "@opentelemetry/api": "^1.4.1",
         "js-yaml": "^4.1.0",
         "ms": "^2.1.3",
-        "nanoid": "^3.3.6",
+        "uuid": "^9.0.1",
         "winston": "^3.8.2"
     },
     "devDependencies": {

package/build/{services → cjs/services}/activities/trigger.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Trigger = void 0;
-const nanoid_1 = require("nanoid");
+const uuid_1 = require("uuid");
 const errors_1 = require("../../modules/errors");
 const utils_1 = require("../../modules/utils");
 const activity_1 = require("./activity");
@@ -137,7 +137,7 @@ class Trigger extends activity_1.Activity {
     }
     resolveJobId(context) {
         const jobId = this.config.stats?.id;
-        return jobId ? pipe_1.Pipe.resolve(jobId, context) : (0, nanoid_1.nanoid)();
+        return jobId ? pipe_1.Pipe.resolve(jobId, context) : (0, uuid_1.v4)();
     }
     resolveJobKey(context) {
         const jobKey = this.config.stats?.key;

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

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ConnectorService = void 0;
-const nanoid_1 = require("nanoid");
+const uuid_1 = require("uuid");
 const utils_1 = require("../../modules/utils");
 const ioredis_1 = require("../connector/clients/ioredis");
 const redis_1 = require("../connector/clients/redis");
@@ -13,12 +13,12 @@ class ConnectorService {
             const instances = [];
             if ((0, utils_1.identifyRedisTypeFromClass)(Redis) === 'redis') {
                 for (let i = 1; i <= 3; i++) {
-                    instances.push(redis_1.RedisConnection.connect((0, nanoid_1.nanoid)(), Redis, options));
+                    instances.push(redis_1.RedisConnection.connect((0, uuid_1.v4)(), Redis, options));
                 }
             }
             else {
                 for (let i = 1; i <= 3; i++) {
-                    instances.push(ioredis_1.RedisConnection.connect((0, nanoid_1.nanoid)(), Redis, options));
+                    instances.push(ioredis_1.RedisConnection.connect((0, uuid_1.v4)(), Redis, options));
                 }
             }
             const [store, stream, sub] = await Promise.all(instances);

package/build/{services → cjs/services}/durable/client.js

@@ -12,7 +12,7 @@ Here is an example of how the methods in this file are used:
 import { Durable } from '@hotmeshio/hotmesh';
 import Redis from 'ioredis';
 import { example } from './workflows';
-import { nanoid } from 'nanoid';
+import { v4 as uuidv4 } from 'uuid';
 
 async function run() {
   const connection = await Durable.Connection.connect({
@@ -31,7 +31,7 @@ async function run() {
     args: ['HotMesh'],
     taskQueue: 'hello-world',
     workflowName: 'example',
-    workflowId: 'workflow-' + nanoid(),
+    workflowId: 'workflow-' + uuidv4(),
   });
 
   console.log(`Started workflow ${handle.workflowId}`);

package/build/{services → cjs/services}/durable/connection.js

@@ -8,7 +8,7 @@ Here is an example of how the methods in this file are used:
 
 import { Durable } from '@hotmeshio/hotmesh';
 import Redis from 'ioredis';
-import { nanoid } from 'nanoid';
+import { v4 as uuidv4 } from 'uuid';
 
 async function run() {
   const connection = await Durable.Connection.connect({
@@ -27,7 +27,7 @@ async function run() {
     taskQueue: 'hello-world',
     args: ['HotMesh'],
     workflowName: 'example',
-    workflowId: nanoid(),
+    workflowId: uuidv4(),
   });
 
   console.log(`Started workflow ${handle.workflowId}`);

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

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.HotMeshService = void 0;
-const nanoid_1 = require("nanoid");
+const uuid_1 = require("uuid");
 const key_1 = require("../../modules/key");
 const engine_1 = require("../engine");
 const logger_1 = require("../logger");
@@ -39,7 +39,7 @@ class HotMeshService {
     }
     static async init(config) {
         const instance = new HotMeshService();
-        instance.guid = (0, nanoid_1.nanoid)();
+        instance.guid = (0, uuid_1.v4)();
         instance.verifyAndSetNamespace(config.namespace);
         instance.verifyAndSetAppId(config.appId);
         instance.logger = new logger_1.LoggerService(config.appId, instance.guid, config.name || '', config.logLevel);

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

@@ -1,6 +1,6 @@
-import { JobState } from "../../types/job";
-import { TransitionRule } from "../../types/transition";
-import { StreamCode } from "../../types";
+import { JobState } from '../../types/job';
+import { TransitionRule } from '../../types/transition';
+import { StreamCode } from '../../types';
 declare class MapperService {
     private rules;
     private data;

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;

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;

package/build/esm/modules/utils.js

@@ -0,0 +1,154 @@
+export async function sleepFor(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+export function identifyRedisType(redisInstance) {
+    if (redisInstance.constructor) {
+        if (redisInstance.constructor.name === 'Redis' || redisInstance.constructor.name === 'EventEmitter') {
+            if ('hset' in redisInstance) {
+                return 'ioredis';
+            }
+        }
+        else if (redisInstance.constructor.name === 'RedisClient' || redisInstance.constructor.name === 'Commander') {
+            if ('HSET' in redisInstance) {
+                return 'redis';
+            }
+        }
+    }
+    return null;
+}
+export function identifyRedisTypeFromClass(redisClass) {
+    if (redisClass && redisClass.name === 'Redis' || redisClass.name === 'EventEmitter') {
+        return 'ioredis';
+    }
+    else if (redisClass && 'createClient' in redisClass) {
+        return 'redis';
+    }
+    return null;
+}
+export function matchesStatusCode(code, pattern) {
+    if (typeof pattern === 'string') {
+        // Convert '*' wildcard to its regex equivalent (\d)
+        const regexPattern = `^${pattern.replace(/\*/g, "\\d")}$`;
+        return new RegExp(regexPattern).test(code.toString());
+    }
+    return pattern.test(code.toString());
+}
+export function matchesStatus(status, targetStatus) {
+    return status === targetStatus;
+}
+export function XSleepFor(ms) {
+    //can be interrupted with `clearTimeout`
+    let timerId;
+    let promise = new Promise((resolve) => {
+        timerId = setTimeout(resolve, ms);
+    });
+    return { promise, timerId };
+}
+export function findTopKey(obj, input) {
+    for (const [key, value] of Object.entries(obj)) {
+        if (value.hasOwnProperty(input)) {
+            const parentKey = findTopKey(obj, key.replace(/^\./, ''));
+            return (parentKey || key).replace(/^\./, '');
+        }
+    }
+    return null;
+}
+export function findSubscriptionForTrigger(obj, value) {
+    for (const [key, itemValue] of Object.entries(obj)) {
+        if (itemValue === value) {
+            return key;
+        }
+    }
+    return 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 async function getSubscriptionTopic(activityId, store, appVID) {
+    const appTransitions = await store.getTransitions(appVID);
+    const appSubscriptions = await store.getSubscriptions(appVID);
+    const triggerId = findTopKey(appTransitions, activityId);
+    const topic = findSubscriptionForTrigger(appSubscriptions, triggerId);
+    return topic;
+}
+/**
+ * returns the 12-digit format of the iso timestamp (e.g, 202101010000)
+ */
+export function getTimeSeries(granularity) {
+    const now = new Date();
+    const granularityUnit = granularity.slice(-1);
+    const granularityValue = parseInt(granularity.slice(0, -1), 10);
+    if (granularityUnit === 'm') {
+        const minute = Math.floor(now.getMinutes() / granularityValue) * granularityValue;
+        now.setUTCMinutes(minute, 0, 0);
+    }
+    else if (granularityUnit === 'h') {
+        now.setUTCMinutes(0, 0, 0);
+    }
+    return now.toISOString().replace(/:\d\d\..+|-|T/g, '').replace(':', '');
+}
+export function formatISODate(input) {
+    const date = input instanceof Date ? input : new Date(input);
+    return date.toISOString().replace(/[:TZ-]/g, '');
+}
+export function getSymKey(number) {
+    const alphabet = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ';
+    const base = alphabet.length;
+    if (number < 0 || number >= Math.pow(base, 3)) {
+        throw new Error('Number out of range');
+    }
+    let [q1, r1] = divmod(number, base);
+    let [q2, r2] = divmod(q1, base);
+    return alphabet[q2] + alphabet[r1] + alphabet[r2];
+}
+export function getSymVal(number) {
+    const alphabet = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ';
+    const base = alphabet.length;
+    if (number < 0 || number >= Math.pow(base, 2)) {
+        throw new Error('Number out of range');
+    }
+    let [q, r] = divmod(number, base);
+    return alphabet[q] + alphabet[r];
+}
+function divmod(m, n) {
+    return [Math.floor(m / n), m % n];
+}
+export function getIndexedHash(hash, target) {
+    const index = hash[target] || 0;
+    const newHash = { ...hash };
+    delete newHash[target];
+    return [index, newHash];
+}
+export function getValueByPath(obj, path) {
+    const pathParts = path.split('/');
+    let currentValue = obj;
+    for (const part of pathParts) {
+        if (currentValue[part] !== undefined) {
+            currentValue = currentValue[part];
+        }
+        else {
+            return undefined;
+        }
+    }
+    return currentValue;
+}
+export function restoreHierarchy(obj) {
+    const result = {};
+    for (const key in obj) {
+        if (obj[key] === undefined)
+            continue;
+        const keys = key.split('/');
+        let current = result;
+        for (let i = 0; i < keys.length; i++) {
+            if (i === keys.length - 1) {
+                current[keys[i]] = obj[key];
+            }
+            else {
+                current[keys[i]] = current[keys[i]] || {};
+                current = current[keys[i]];
+            }
+        }
+    }
+    return result;
+}