@hotmeshio/hotmesh 0.0.8 → 0.0.10

package/services/hotmesh/index.ts

@@ -1,5 +1,5 @@
 import { v4 as uuidv4 } from 'uuid';
-import { PSNS } from '../../modules/key';
+import { HMNS } from '../../modules/key';
 import { EngineService } from '../engine';
 import { LoggerService, ILogger } from '../logger';
 import { StreamSignaler } from '../signaler/stream';
@@ -33,7 +33,7 @@ class HotMeshService {
 
   verifyAndSetNamespace(namespace?: string) {
     if (!namespace) {
-      this.namespace = PSNS;
+      this.namespace = HMNS;
     } else if (!namespace.match(/^[A-Za-z0-9-]+$/)) {
       throw new Error(`config.namespace [${namespace}] is invalid`);
     } else {

package/services/store/index.ts

@@ -2,7 +2,7 @@ import {
   KeyService,
   KeyStoreParams,
   KeyType, 
-  PSNS} from '../../modules/key';
+  HMNS} from '../../modules/key';
 import { ILogger } from '../logger';
 import { MDATA_SYMBOLS, SerializerService as Serializer } from '../serializer';
 import { Cache } from './cache';
@@ -119,7 +119,7 @@ abstract class StoreService<T, U extends AbstractRedisClient> {
     this.redisClient = redisClient;
   }
 
-  async init(namespace = PSNS, appId: string, logger: ILogger): Promise<HotMeshApps> {
+  async init(namespace = HMNS, appId: string, logger: ILogger): Promise<HotMeshApps> {
     this.namespace = namespace;
     this.appId = appId;
     this.logger = logger;
@@ -178,7 +178,7 @@ abstract class StoreService<T, U extends AbstractRedisClient> {
       if (bCreate) {
         const packageJson = await import('../../package.json');
         const version: string = packageJson['version'] || '0.0.0';
-        settings = { namespace: PSNS, version } as HotMeshSettings;
+        settings = { namespace: HMNS, version } as HotMeshSettings;
         await this.setSettings(settings);
         return settings;
       }

package/services/stream/clients/ioredis.ts

@@ -1,4 +1,4 @@
-import { KeyService, KeyStoreParams, KeyType, PSNS } from '../../../modules/key';
+import { KeyService, KeyStoreParams, KeyType, HMNS } from '../../../modules/key';
 import { ILogger } from '../../logger';
 import { StreamService } from '../index';
 import { RedisClientType, RedisMultiType } from '../../../types/ioredisclient';
@@ -14,7 +14,7 @@ class IORedisStreamService extends StreamService<RedisClientType, RedisMultiType
     super(redisClient);
   }
 
-  async init(namespace = PSNS, appId: string, logger: ILogger): Promise<void> {
+  async init(namespace = HMNS, appId: string, logger: ILogger): Promise<void> {
     this.namespace = namespace;
     this.logger = logger;
     this.appId = appId;

package/services/stream/clients/redis.ts

@@ -1,4 +1,4 @@
-import { KeyService, KeyStoreParams, KeyType, PSNS } from '../../../modules/key';
+import { KeyService, KeyStoreParams, KeyType, HMNS } from '../../../modules/key';
 import { ILogger } from '../../logger';
 import { StreamService } from '../index';
 import { RedisClientType, RedisMultiType } from '../../../types/redisclient';
@@ -14,7 +14,7 @@ class RedisStreamService extends StreamService<RedisClientType, RedisMultiType>
     super(redisClient);
   }
 
-  async init(namespace = PSNS, appId: string, logger: ILogger): Promise<void> {
+  async init(namespace = HMNS, appId: string, logger: ILogger): Promise<void> {
     this.namespace = namespace;
     this.logger = logger;
     this.appId = appId;

package/services/sub/clients/ioredis.ts

@@ -1,4 +1,4 @@
-import { KeyService, KeyStoreParams, KeyType, PSNS } from '../../../modules/key';
+import { KeyService, KeyStoreParams, KeyType, HMNS } from '../../../modules/key';
 import { ILogger } from '../../logger';
 import { SubService } from '../index';
 import { RedisClientType, RedisMultiType } from '../../../types/ioredisclient';
@@ -14,7 +14,7 @@ class IORedisSubService extends SubService<RedisClientType, RedisMultiType> {
     super(redisClient);
   }
 
-  async init(namespace = PSNS, appId: string, engineId: string, logger: ILogger): Promise<void> {
+  async init(namespace = HMNS, appId: string, engineId: string, logger: ILogger): Promise<void> {
     this.namespace = namespace;
     this.logger = logger;
     this.appId = appId;

package/services/sub/clients/redis.ts

@@ -1,4 +1,4 @@
-import { KeyService, KeyStoreParams, KeyType, PSNS } from '../../../modules/key';
+import { KeyService, KeyStoreParams, KeyType, HMNS } from '../../../modules/key';
 import { ILogger } from '../../logger';
 import { SubService } from '../index';
 import { RedisClientType, RedisMultiType } from '../../../types/redisclient';
@@ -14,7 +14,7 @@ class RedisSubService extends SubService<RedisClientType, RedisMultiType> {
     super(redisClient);
   }
 
-  async init(namespace = PSNS, appId: string, engineId: string, logger: ILogger): Promise<void> {
+  async init(namespace = HMNS, appId: string, engineId: string, logger: ILogger): Promise<void> {
     this.namespace = namespace;
     this.logger = logger;
     this.appId = appId;

package/types/durable.ts

@@ -39,10 +39,9 @@ type Registry  = {
 
 type WorkerConfig = {
   connection: Connection;
-  namespace: string; //`appid` in the YAML (e.g, 'default')
+  namespace?: string; //`appid` in the YAML (e.g, 'default')
   taskQueue: string; //`subscribes` in the YAML (e.g, 'hello-world')
-  workflowsPath: string; //resolved abs path to dyn import()
-  activities: { [key: string]: Function }; //vanilla activity exports
+  workflow: Function //target function to run
 }
 
 type ContextType = {
@@ -56,8 +55,9 @@ type ProxyType<ACT> = {
 };
 
 type ActivityConfig = {
-  startToCloseTimeout: string;
-  retryPolicy: {
+  startToCloseTimeout?: string;
+  activities?: any;
+  retryPolicy?: {
     initialInterval: string;
     maximumAttempts: number;
     backoffCoefficient: number;

package/build/cjs/package.json

@@ -1,82 +0,0 @@
-{
-    "name": "@hotmeshio/hotmesh",
-    "version": "0.0.8",
-    "description": "Durable Workflows",
-    "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"
-    },
-    "homepage": "https://github.com/hotmeshio/sdk-typescript#readme",
-    "publishConfig": {
-        "access": "public"
-    },
-    "scripts": {
-        "clean": "rimraf ./build",
-        "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",
-        "start": "ts-node src/index.ts",
-        "test": "NODE_ENV=test jest --detectOpenHandles --forceExit --verbose",
-        "test:hmsh": "NODE_ENV=test jest ./tests/functional/index.test.ts --detectOpenHandles --verbose",
-        "test:compile": "NODE_ENV=test jest ./tests/functional/compile/index.test.ts --detectOpenHandles --forceExit --verbose",
-        "test:cycle": "NODE_ENV=test jest ./tests/functional/cycle/index.test.ts --detectOpenHandles --forceExit --verbose",
-        "test:connect": "NODE_ENV=test jest ./tests/unit/services/connector/index.test.ts --detectOpenHandles --forceExit --verbose",
-        "test:connect:redis": "NODE_ENV=test jest ./tests/unit/services/connector/clients/redis.test.ts --detectOpenHandles --forceExit --verbose",
-        "test:connect:ioredis": "NODE_ENV=test jest ./tests/unit/services/connector/clients/ioredis.test.ts --detectOpenHandles --forceExit --verbose",
-        "test:parallel": "NODE_ENV=test jest ./tests/functional/parallel/index.test.ts --detectOpenHandles --forceExit --verbose",
-        "test:sequence": "NODE_ENV=test jest ./tests/functional/sequence/index.test.ts --detectOpenHandles --forceExit --verbose",
-        "test:quorum": "NODE_ENV=test jest ./tests/functional/quorum/index.test.ts --detectOpenHandles --forceExit --verbose",
-        "test:reclaim": "NODE_ENV=test jest ./tests/functional/reclaim/index.test.ts --detectOpenHandles --forceExit --verbose",
-        "test:redeploy": "NODE_ENV=test jest ./tests/functional/redeploy/index.test.ts --detectOpenHandles --forceExit --verbose",
-        "test:retry": "NODE_ENV=test jest ./tests/functional/retry/index.test.ts --detectOpenHandles --forceExit --verbose",
-        "test:status": "NODE_ENV=test jest ./tests/functional/status/index.test.ts --detectOpenHandles --forceExit --verbose",
-        "test:store:redis": "NODE_ENV=test jest ./tests/functional/store/clients/redis.test.ts --detectOpenHandles --forceExit --verbose",
-        "test:store:ioredis": "NODE_ENV=test jest ./tests/functional/store/clients/ioredis.test.ts --detectOpenHandles --forceExit --verbose",
-        "test:stream:redis": "NODE_ENV=test jest ./tests/functional/stream/clients/redis.test.ts --detectOpenHandles --forceExit --verbose",
-        "test:stream:ioredis": "NODE_ENV=test jest ./tests/functional/stream/clients/ioredis.test.ts --detectOpenHandles --forceExit --verbose",
-        "test:sub:redis": "NODE_ENV=test jest ./tests/functional/sub/clients/redis.test.ts --detectOpenHandles --forceExit --verbose",
-        "test:sub:ioredis": "NODE_ENV=test jest ./tests/functional/sub/clients/ioredis.test.ts --detectOpenHandles --forceExit --verbose",
-        "test:durable": "NODE_ENV=test jest ./tests/durable/*/index.test.ts --detectOpenHandles --forceExit --verbose",
-        "test:durable:hello": "NODE_ENV=test jest ./tests/durable/helloworld/index.test.ts --detectOpenHandles --forceExit --verbose",
-        "test:durable:goodbye": "NODE_ENV=test jest ./tests/durable/goodbye/index.test.ts --detectOpenHandles --forceExit --verbose",
-        "test:durable:retry": "NODE_ENV=test jest ./tests/durable/retry/index.test.ts --detectOpenHandles --forceExit --verbose",
-        "test:durable:loopactivity": "NODE_ENV=test jest ./tests/durable/loopactivity/index.test.ts --detectOpenHandles --forceExit --verbose",
-        "test:durable:nested": "NODE_ENV=test jest ./tests/durable/nested/index.test.ts --detectOpenHandles --forceExit --verbose"
-    },
-    "keywords": [],
-    "author": "luke.birdeau@gmail.com",
-    "license": "SEE LICENSE IN LICENSE",
-    "dependencies": {
-        "@apidevtools/json-schema-ref-parser": "^10.1.0",
-        "@opentelemetry/api": "^1.4.1",
-        "js-yaml": "^4.1.0",
-        "ms": "^2.1.3",
-        "uuid": "^9.0.1",
-        "winston": "^3.8.2"
-    },
-    "devDependencies": {
-        "@types/jest": "^29.5.0",
-        "@types/node": "^18.15.11",
-        "@typescript-eslint/eslint-plugin": "^5.56.0",
-        "@typescript-eslint/parser": "^5.56.0",
-        "eslint": "^8.36.0",
-        "ioredis": "^5.3.2",
-        "jest": "^29.5.0",
-        "redis": "^4.6.6",
-        "rimraf": "^4.4.1",
-        "ts-jest": "^29.0.5",
-        "ts-node": "^10.9.1",
-        "ts-node-dev": "^2.0.0",
-        "typescript": "^5.0.4"
-    }
-}

package/build/cjs/services/durable/worker.d.ts

@@ -1,38 +0,0 @@
-import { HotMeshService as HotMesh } from '../hotmesh';
-import { Connection, Registry, WorkerConfig } from "../../types/durable";
-export declare class WorkerService {
-    static activityRegistry: Registry;
-    static connection: Connection;
-    static instances: Map<string, HotMesh | Promise<HotMesh>>;
-    workflowRunner: HotMesh;
-    activityRunner: HotMesh;
-    static getHotMesh: (worflowTopic: string) => Promise<HotMesh>;
-    static activateWorkflow(hotMesh: HotMesh, topic: string, factory: Function): Promise<void>;
-    /**
-     * The `worker` calls `registerActivities` immediately BEFORE
-     * dynamically importing the user's workflow module. That file
-     * contains a call, `proxyActivities`, which needs this info.
-     *
-     * NOTE: The `worker` and `client` both call `proxyActivities`,
-     * as a natural result of importing worflows.ts. However,
-     * because the worker imports the workflows dynamically AFTER
-     * the activities are loaded, there will be items in the registry,
-     * allowing proxyActivities to succeed.
-     */
-    static registerActivities<ACT>(activities: ACT): Registry;
-    static create(config: WorkerConfig): Promise<WorkerService>;
-    static resolveWorkflowTarget(workflow: object | Function): [string, Function];
-    run(): Promise<void>;
-    initActivityWorkflow(config: WorkerConfig, activityTopic: string): Promise<HotMesh>;
-    wrapActivityFunctions(): Function;
-    activateActivityWorkflow(hotMesh: HotMesh, activityTopic: string): Promise<void>;
-    initWorkerWorkflow(config: WorkerConfig, workflowTopic: string, workflowFunction: Function): Promise<HotMesh>;
-    static Context: {
-        info: () => {
-            workflowId: string;
-            workflowTopic: string;
-        };
-    };
-    wrapWorkflowFunction(workflowFunction: Function, workflowTopic: string): Function;
-    static shutdown(): Promise<void>;
-}

package/build/esm/index.d.ts

@@ -1,4 +0,0 @@
-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

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

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

@@ -1,28 +0,0 @@
-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

@@ -1,41 +0,0 @@
-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

@@ -1,75 +0,0 @@
-/**
- * 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

@@ -1,111 +0,0 @@
-/**
- * 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

@@ -1,34 +0,0 @@
-/// <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;