@hotmeshio/hotmesh 0.0.38 → 0.0.40

package/build/types/index.d.ts

@@ -10,12 +10,13 @@ export { ILogger } from './logger';
 export { JobData, JobsData, JobMetadata, JobOutput, JobState, JobStatus, PartialJobState } from './job';
 export { MappingStatements } from './map';
 export { Pipe, PipeItem, PipeItems } from './pipe';
-export { HotMesh, HotMeshApp, HotMeshApps, HotMeshConfig, HotMeshEngine, RedisConfig, HotMeshGraph, HotMeshManifest, HotMeshSettings, HotMeshWorker } from './hotmesh';
-export { ActivateMessage, JobMessage, JobMessageCallback, PingMessage, PongMessage, QuorumMessage, SubscriptionCallback, ThrottleMessage, WorkMessage } from './quorum';
+export { HotMesh, HotMeshApp, HotMeshApps, HotMeshConfig, HotMeshEngine, RedisConfig, HotMeshGraph, HotMeshManifest, HotMeshSettings, HotMeshWorker, KeyStoreParams, KeyType } from './hotmesh';
+export { ActivateMessage, JobMessage, JobMessageCallback, PingMessage, PongMessage, QuorumMessage, QuorumMessageCallback, QuorumProfile, SubscriptionCallback, ThrottleMessage, WorkMessage } from './quorum';
 export { MultiResponseFlags, RedisClient, RedisMulti } from './redis';
 export { RedisClientType, RedisMultiType } from './redisclient';
 export { JSONSchema, StringAnyType, StringScalarType, StringStringType, SymbolMap, SymbolMaps, SymbolRanges, Symbols, SymbolSets } from './serializer';
 export { AggregatedData, CountByFacet, GetStatsOptions, IdsData, Measure, MeasureIds, MetricTypes, StatType, StatsType, IdsResponse, JobStats, JobStatsInput, JobStatsRange, StatsResponse, Segment, TimeSegment } from './stats';
 export { ReclaimedMessageType, StreamCode, StreamConfig, StreamData, StreamDataType, StreamError, StreamDataResponse, StreamRetryPolicy, StreamRole, StreamStatus } from './stream';
 export { context, Context, Counter, Meter, metrics, propagation, SpanContext, Span, SpanStatus, SpanStatusCode, SpanKind, trace, Tracer, ValueType } from './telemetry';
+export { WorkListTaskType } from './task';
 export { TransitionMatch, TransitionRule, Transitions } from './transition';

package/build/types/index.js

@@ -1,12 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ValueType = exports.trace = exports.SpanKind = exports.SpanStatusCode = exports.propagation = exports.metrics = exports.context = exports.StreamStatus = exports.StreamRole = exports.StreamDataType = exports.IORedisClientType = exports.HookGate = exports.CollationFaultType = void 0;
+exports.ValueType = exports.trace = exports.SpanKind = exports.SpanStatusCode = exports.propagation = exports.metrics = exports.context = exports.StreamStatus = exports.StreamRole = exports.StreamDataType = exports.KeyType = exports.IORedisClientType = exports.HookGate = exports.CollationFaultType = void 0;
 var collator_1 = require("./collator");
 Object.defineProperty(exports, "CollationFaultType", { enumerable: true, get: function () { return collator_1.CollationFaultType; } });
 var hook_1 = require("./hook");
 Object.defineProperty(exports, "HookGate", { enumerable: true, get: function () { return hook_1.HookGate; } });
 var ioredisclient_1 = require("./ioredisclient");
 Object.defineProperty(exports, "IORedisClientType", { enumerable: true, get: function () { return ioredisclient_1.RedisClientType; } });
+var hotmesh_1 = require("./hotmesh");
+Object.defineProperty(exports, "KeyType", { enumerable: true, get: function () { return hotmesh_1.KeyType; } });
 var stream_1 = require("./stream");
 Object.defineProperty(exports, "StreamDataType", { enumerable: true, get: function () { return stream_1.StreamDataType; } });
 Object.defineProperty(exports, "StreamRole", { enumerable: true, get: function () { return stream_1.StreamRole; } });

package/build/types/logger.d.ts

@@ -4,3 +4,4 @@ export interface ILogger {
     warn(message: string, ...meta: any[]): void;
     debug(message: string, ...meta: any[]): void;
 }
+export type LogLevel = 'silly' | 'debug' | 'info' | 'warn' | 'error' | 'silent';

package/build/types/logger.js

@@ -1,2 +1,3 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+;

package/build/types/task.d.ts

@@ -0,0 +1 @@
+export type WorkListTaskType = 'sleep' | 'expire' | 'interrupt' | 'delist';

package/build/types/task.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/modules/enums.ts

@@ -1,35 +1,49 @@
-// Engine Constants
-export const STATUS_CODE_SUCCESS = 200;
-export const STATUS_CODE_PENDING = 202;
-export const STATUS_CODE_TIMEOUT = 504;
-export const STATUS_CODE_INTERRUPT = 410;
-export const OTT_WAIT_TIME = 1000;
-
-// Stream Constants
-export const MAX_RETRIES = 3; //local retry; 10, 100, 1000ms
-export const MAX_TIMEOUT_MS = 60000;
-export const GRADUATED_INTERVAL_MS = 5000;
-
-export const BLOCK_DURATION = 15000; //Set to `15` so SIGINT/SIGTERM can interrupt; set to `0` to BLOCK indefinitely
-export const TEST_BLOCK_DURATION = 1000; //Set to `1000` so tests can interrupt quickly
-export const BLOCK_TIME_MS = process.env.NODE_ENV === 'test' ? TEST_BLOCK_DURATION : BLOCK_DURATION;
-
-export const XCLAIM_DELAY_MS = 1000 * 60; //max time a message can be unacked before it is claimed by another
-export const XCLAIM_COUNT = 3; //max number of times a message can be claimed by another before it is dead-lettered
-export const XPENDING_COUNT = 10;
-
-export const STATUS_CODE_UNACKED = 999;
-export const STATUS_CODE_UNKNOWN = 500;
-export const STATUS_MESSAGE_UNKNOWN = 'unknown';
-
-// HotMesh Constants
-export const EXPIRE_DURATION = 15;        // default expire in seconds; once job state semaphore reaches '0', this is applied to set Redis to expire the job HASH
-export const BASE_FIDELITY_SECONDS = 15;  // granularity resolution window size
-export const TEST_FIDELITY_SECONDS = 5;
-export const FIDELITY_SECONDS = process.env.NODE_ENV === 'test' ? TEST_FIDELITY_SECONDS : BASE_FIDELITY_SECONDS
-
-// DURABLE CONSTANTS
-export const DURABLE_EXPIRE_SECONDS = 1;
-
-// TASK CONSTANTS
-export const SCOUT_INTERVAL_SECONDS = 60;
+import { LogLevel } from "../types/logger";
+
+// HOTMESH SYSTEM
+export const HMSH_LOGLEVEL = process.env.HMSH_LOGLEVEL as LogLevel || 'info';
+
+// STATUS CODES AND MESSAGES
+export const HMSH_CODE_SUCCESS = 200;
+export const HMSH_CODE_PENDING = 202;
+export const HMSH_CODE_NOTFOUND = 404;
+export const HMSH_CODE_INTERRUPT = 410;
+export const HMSH_CODE_UNKNOWN = 500;
+export const HMSH_CODE_TIMEOUT = 504;
+export const HMSH_CODE_UNACKED = 999;
+
+export const HMSH_CODE_DURABLE_SLEEPFOR = 592;
+export const HMSH_CODE_DURABLE_INCOMPLETE = 593;
+export const HMSH_CODE_DURABLE_WAITFOR = 594;
+export const HMSH_CODE_DURABLE_TIMEOUT = 596;
+export const HMSH_CODE_DURABLE_MAXED = 597;
+export const HMSH_CODE_DURABLE_FATAL = 598;
+export const HMSH_CODE_DURABLE_RETRYABLE = 599;
+
+export const HMSH_STATUS_UNKNOWN = 'unknown';
+
+// ENGINE
+export const HMSH_OTT_WAIT_TIME = parseInt(process.env.HMSH_OTT_WAIT_TIME, 10) || 1000;
+export const HMSH_EXPIRE_JOB_SECONDS = parseInt(process.env.HMSH_EXPIRE_JOB_SECONDS, 10) || 1;
+
+// STREAM ROUTER
+export const HMSH_MAX_RETRIES = parseInt(process.env.HMSH_MAX_RETRIES, 10) || 3;
+export const HMSH_MAX_TIMEOUT_MS = parseInt(process.env.HMSH_MAX_TIMEOUT_MS, 10) || 60000;
+export const HMSH_GRADUATED_INTERVAL_MS = parseInt(process.env.HMSH_GRADUATED_INTERVAL_MS, 10) || 5000;
+
+const BASE_BLOCK_DURATION = 10000; // Modified for clarity
+const TEST_BLOCK_DURATION = 1000; // Modified for clarity
+export const HMSH_BLOCK_TIME_MS = process.env.HMSH_BLOCK_TIME_MS ? parseInt(process.env.HMSH_BLOCK_TIME_MS, 10) : (process.env.NODE_ENV === 'test' ? TEST_BLOCK_DURATION : BASE_BLOCK_DURATION);
+
+export const HMSH_XCLAIM_DELAY_MS = parseInt(process.env.HMSH_XCLAIM_DELAY_MS, 10) || 1000 * 60;
+export const HMSH_XCLAIM_COUNT = parseInt(process.env.HMSH_XCLAIM_COUNT, 10) || 3;
+export const HMSH_XPENDING_COUNT = parseInt(process.env.HMSH_XPENDING_COUNT, 10) || 10;
+
+// TASK WORKER
+export const HMSH_EXPIRE_DURATION = parseInt(process.env.HMSH_EXPIRE_DURATION, 10) || 1;
+
+const BASE_FIDELITY_SECONDS = 5;
+const TEST_FIDELITY_SECONDS = 5;
+export const HMSH_FIDELITY_SECONDS = process.env.HMSH_FIDELITY_SECONDS ? parseInt(process.env.HMSH_FIDELITY_SECONDS, 10) : (process.env.NODE_ENV === 'test' ? TEST_FIDELITY_SECONDS : BASE_FIDELITY_SECONDS);
+
+export const HMSH_SCOUT_INTERVAL_SECONDS = parseInt(process.env.HMSH_SCOUT_INTERVAL_SECONDS, 10) || 60;

package/modules/errors.ts

@@ -1,9 +1,18 @@
 import { ActivityDuplex } from "../types/activity";
 import { CollationFaultType, CollationStage } from "../types/collator";
+import {
+  HMSH_CODE_DURABLE_MAXED,
+  HMSH_CODE_DURABLE_TIMEOUT,
+  HMSH_CODE_DURABLE_FATAL,
+  HMSH_CODE_DURABLE_INCOMPLETE,
+  HMSH_CODE_NOTFOUND,
+  HMSH_CODE_DURABLE_RETRYABLE,
+  HMSH_CODE_DURABLE_SLEEPFOR,
+  HMSH_CODE_DURABLE_WAITFOR } from "./enums";
 
 class GetStateError extends Error {
   jobId: string;
-  code: 404;
+  code = HMSH_CODE_NOTFOUND;
   constructor(jobId: string) {
     super(`${jobId} Not Found`);
     this.jobId = jobId;
@@ -21,7 +30,7 @@ class DurableIncompleteSignalError extends Error {
   code: number;
   constructor(message: string) {
     super(message);
-    this.code = 593;
+    this.code = HMSH_CODE_DURABLE_INCOMPLETE;
   }
 }
 
@@ -32,7 +41,7 @@ class DurableWaitForSignalError extends Error {
   constructor(message: string, signals: {signal: string, index: number}[]) {
     super(message);
     this.signals = signals;
-    this.code = 594;
+    this.code = HMSH_CODE_DURABLE_WAITFOR;
   }
 }
 
@@ -60,35 +69,35 @@ class DurableSleepForError extends Error {
     this.duration = duration;
     this.index = index;
     this.dimension = dimension;
-    this.code = 592;
+    this.code = HMSH_CODE_DURABLE_SLEEPFOR;
   }
 }
 class DurableTimeoutError extends Error {
   code: number;
   constructor(message: string) {
     super(message);
-    this.code = 596;
+    this.code = HMSH_CODE_DURABLE_TIMEOUT;
   }
 }
 class DurableMaxedError extends Error {
   code: number;
   constructor(message: string) {
     super(message);
-    this.code = 597;
+    this.code = HMSH_CODE_DURABLE_MAXED;
   }
 }
 class DurableFatalError extends Error {
   code: number;
   constructor(message: string) {
     super(message);
-    this.code = 598;
+    this.code = HMSH_CODE_DURABLE_FATAL;
   }
 }
 class DurableRetryError extends Error {
   code: number;
   constructor(message: string) {
     super(message);
-    this.code = 599;
+    this.code = HMSH_CODE_DURABLE_RETRYABLE;
   }
 }
 

package/modules/key.ts

@@ -1,3 +1,5 @@
+import { KeyStoreParams, KeyType } from '../types/hotmesh';
+
 /**
  * Keys
  * 
@@ -26,46 +28,7 @@
  * hmsh:<appid>:sym:vals: ->                          {hash}    list of symbols for job values across all app versions
  */
 
-//default namespace for hotmesh
-const HMNS = "hmsh";
-
-//these are the entity types that are stored in the key/value store
-enum KeyType {
-  APP = 'APP',
-  ENGINE_ID = 'ENGINE',
-  HOOKS = 'HOOKS',
-  JOB_DEPENDENTS = 'JOB_DEPENDENTS',
-  JOB_STATE = 'JOB_STATE',
-  JOB_STATS_GENERAL = 'JOB_STATS_GENERAL',
-  JOB_STATS_MEDIAN = 'JOB_STATS_MEDIAN',
-  JOB_STATS_INDEX = 'JOB_STATS_INDEX',
-  HOTMESH = 'HOTMESH',
-  QUORUM = 'QUORUM',
-  SCHEMAS = 'SCHEMAS',
-  SIGNALS = 'SIGNALS',
-  STREAMS = 'STREAMS',
-  SUBSCRIPTIONS = 'SUBSCRIPTIONS',
-  SUBSCRIPTION_PATTERNS = 'SUBSCRIPTION_PATTERNS',
-  SYMKEYS = 'SYMKEYS',
-  SYMVALS = 'SYMVALS',
-  TIME_RANGE = 'TIME_RANGE',
-  WORK_ITEMS = 'WORK_ITEMS',
-}
-
-//when minting a key, the following parameters are used to create a unique key per entity
-type KeyStoreParams = {
-  appId?: string;       //app id is a uuid for a hotmesh app
-  engineId?: string;    //unique auto-generated guid for an ephemeral engine instance
-  appVersion?: string;  //(e.g. "1.0.0", "1", "1.0")
-  jobId?: string;       //a customer-defined id for job; must be unique for the entire app
-  activityId?: string;  //activity id is a uuid for a given hotmesh app
-  jobKey?: string;      //a customer-defined label for a job that serves to categorize events 
-  dateTime?: string;    //UTC date time: YYYY-MM-DDTHH:MM (20203-04-12T00:00); serves as a time-series bucket for the job_key
-  facet?: string;       //data path starting at root with values separated by colons (e.g. "object/type:bar")
-  topic?: string;       //topic name (e.g., "foo" or "" for top-level)
-  timeValue?: number;   //time value (rounded to minute) (for delete range)
-  scoutType?: 'signal' | 'time'; //a single member of the quorum serves as the 'scout' for the group, triaging tasks for the collective
-};
+const HMNS = "hmsh"; //default
 
 class KeyService {
 

package/package.json

@@ -1,9 +1,9 @@
 {
   "name": "@hotmeshio/hotmesh",
-  "version": "0.0.38",
+  "version": "0.0.40",
   "description": "Unbreakable Workflows",
-  "main": "build/index.js",
-  "types": "build/index.d.ts",
+  "main": "./build/index.js",
+  "types": "./build/types/index.d.ts",
   "repository": {
     "type": "git",
     "url": "https://github.com/hotmeshio/sdk-typescript.git"

package/services/activities/activity.ts

@@ -1,4 +1,4 @@
-import { EXPIRE_DURATION } from '../../modules/enums';
+import { HMSH_EXPIRE_DURATION } from '../../modules/enums';
 import {
   CollationError,
   GenerationalError,
@@ -435,7 +435,7 @@ class Activity {
 
   initPolicies(context: JobState) {
     const expire = Pipe.resolve(
-      this.config.expire ?? EXPIRE_DURATION,
+      this.config.expire ?? HMSH_EXPIRE_DURATION,
       context
     );
     context.metadata.expire = expire;

package/services/activities/hook.ts

@@ -131,16 +131,25 @@ class Hook extends Activity {
 
   async registerHook(multi?: RedisMulti): Promise<string | void> {
     if (this.config.hook?.topic) {
-      const taskService = new TaskService(this.store, this.logger);
-      return await taskService.registerWebHook(this.config.hook.topic, this.context, this.resolveDad(), multi);
+      return await this.engine.taskService.registerWebHook(
+        this.config.hook.topic,
+        this.context,
+        this.resolveDad(),
+        multi
+      );
     } else if (this.config.sleep) {
-      const durationInSeconds = Pipe.resolve(this.config.sleep, this.context);
-      const jobId = this.context.metadata.jid;
-      const gId = this.context.metadata.gid;
-      const activityId = this.metadata.aid;
-      const dId = this.metadata.dad;
-      await this.engine.taskService.registerTimeHook(jobId, gId, `${activityId}${dId||''}`, 'sleep', durationInSeconds);
-      return jobId;
+      const duration = Pipe.resolve(
+        this.config.sleep,
+        this.context,
+      );
+      await this.engine.taskService.registerTimeHook(
+        this.context.metadata.jid,
+        this.context.metadata.gid,
+        `${this.metadata.aid}${this.metadata.dad || ''}`,
+        'sleep',
+        duration,
+      );
+      return this.context.metadata.jid;
     }
   }
 

package/services/activities/trigger.ts

@@ -47,7 +47,7 @@ class Trigger extends Activity {
       const multi = this.store.getMulti();
       await this.setState(multi);
       await this.setStats(multi);
-      await this.setDependency(multi);
+      await this.registerJobDependency(multi);
       await multi.exec();
 
       telemetry.mapActivityAttributes();
@@ -180,13 +180,17 @@ class Trigger extends Activity {
   }
 
   /**
-   * Registers this job as a dependent of the parent job
+   * Registers this job as a dependent of the parent job; when the
+   * parent job is interrupted, this job will be interrupted
    */
-  async setDependency(multi?: RedisMulti): Promise<void> {
-    const depKey = this.config.stats?.parent;
-    const resolvedDepKey = depKey ? Pipe.resolve(depKey, this.context) : '';
+  async registerJobDependency(multi?: RedisMulti): Promise<void> {
+    const depKey = this.config.stats?.parent ?? this.context.metadata.pj;
+    let resolvedDepKey = depKey ? Pipe.resolve(depKey, this.context) : '';
+    if (!resolvedDepKey) {
+      resolvedDepKey = this.context.metadata.pj;
+    }
     if (resolvedDepKey) {
-      await this.store.setDependency(
+      await this.store.registerJobDependency(
         resolvedDepKey,
         this.context.metadata.tpc,
         this.context.metadata.jid,

package/services/durable/client.ts

@@ -11,11 +11,12 @@ import { JobState } from '../../types/job';
 import { KeyService, KeyType } from '../../modules/key';
 import { Search } from './search';
 import { StreamStatus } from '../../types';
-import { DURABLE_EXPIRE_SECONDS } from '../../modules/enums';
+import { HMSH_LOGLEVEL, HMSH_EXPIRE_JOB_SECONDS } from '../../modules/enums';
 
 export class ClientService {
 
   connection: Connection;
+  topics: string[] = [];
   options: WorkflowOptions;
   static instances = new Map<string, HotMesh | Promise<HotMesh>>();
 
@@ -23,14 +24,22 @@ export class ClientService {
     this.connection = config.connection;
   }
 
-  getHotMeshClient = async (worflowTopic: string, namespace?: string) => {
-    //NOTE: every unique topic inits a new engine
-    if (ClientService.instances.has(worflowTopic)) {
-      return await ClientService.instances.get(worflowTopic);
+  getHotMeshClient = async (workflowTopic: string, namespace?: string) => {
+    //use the cached instance
+    const instanceId = 'SINGLETON';
+    if (ClientService.instances.has(instanceId)) {
+      const hotMeshClient = await ClientService.instances.get(instanceId);
+      if (!this.topics.includes(workflowTopic)) {
+        this.topics.push(workflowTopic);
+        await this.createStream(hotMeshClient, workflowTopic, namespace);
+      }
+      return hotMeshClient;
     }
 
+    //create and cache an instance
     const hotMeshClient = HotMesh.init({
       appId: namespace ?? APP_ID,
+      logLevel: HMSH_LOGLEVEL,
       engine: {
         redis: {
           class: this.connection.class,
@@ -38,19 +47,27 @@ export class ClientService {
         }
       }
     });
-    ClientService.instances.set(worflowTopic, hotMeshClient);
+    ClientService.instances.set(instanceId, hotMeshClient);
+    await this.createStream(await hotMeshClient, workflowTopic, namespace);
+    await this.activateWorkflow(await hotMeshClient, namespace ?? APP_ID);
+    return hotMeshClient;
+  }
 
-    //since the YAML topic is dynamic, it MUST be manually created before use
-    const store = (await hotMeshClient).engine.store;
-    const params = { appId: namespace ?? APP_ID, topic: worflowTopic };
+  /**
+   * Creates a stream (Redis `XGROUP.CREATE`) where events can be published (XADD).
+   * It is possible that the worker that will read from this stream channel
+   * has not yet been initialized, so this call ensures that the channel
+   * exists and is ready to serve as a container for events.
+   */
+  createStream = async(hotMeshClient: HotMesh, workflowTopic: string, namespace?: string) => {
+    const store = hotMeshClient.engine.store;
+    const params = { appId: namespace ?? APP_ID, topic: workflowTopic };
     const streamKey = store.mintKey(KeyType.STREAMS, params);
     try {
       await store.xgroup('CREATE', streamKey, 'WORKER', '$', 'MKSTREAM');
     } catch (err) {
       //ignore if already exists
     }
-    await this.activateWorkflow(await hotMeshClient, namespace ?? APP_ID);
-    return hotMeshClient;
   }
 
   /**
@@ -105,7 +122,7 @@ export class ClientService {
       const payload = {
         arguments: [...options.args],
         originJobId: options.originJobId,
-        expire: options.expire ?? DURABLE_EXPIRE_SECONDS,
+        expire: options.expire ?? HMSH_EXPIRE_JOB_SECONDS,
         parentWorkflowId: options.parentWorkflowId,
         workflowId: options.workflowId || HotMesh.guid(),
         workflowTopic: workflowTopic,
@@ -155,9 +172,8 @@ export class ClientService {
       if (options.search?.data) {
         const searchSessionId = `-search-${HotMesh.guid()}-0`;
         const search = new Search(options.workflowId, hotMeshClient, searchSessionId);
-        for (const [key, value] of Object.entries(options.search.data)) {
-          search.set(key, value);
-        }
+        const entries = Object.entries(options.search.data).flat();
+        await search.set(...entries);
       }
       return msgId;
     },

package/services/durable/handle.ts

@@ -1,4 +1,4 @@
-import { STATUS_CODE_INTERRUPT } from '../../modules/enums';
+import { HMSH_CODE_INTERRUPT } from '../../modules/enums';
 import { HotMeshService as HotMesh } from '../hotmesh';
 import { JobInterruptOptions, JobOutput } from '../../types/job';
 import { StreamError } from '../../types/stream';
@@ -101,7 +101,7 @@ export class WorkflowHandleService {
           const state = await this.hotMesh.getState(`${this.hotMesh.appId}.execute`, this.workflowId);
           if (state.metadata.err) {
             const error = JSON.parse(state.metadata.err) as StreamError;
-            if (error.code === STATUS_CODE_INTERRUPT || !state.data) {
+            if (error.code === HMSH_CODE_INTERRUPT || !state.data) {
               return reject({ ...error, job_id: this.workflowId });
             }
           }
@@ -117,7 +117,7 @@ export class WorkflowHandleService {
       this.hotMesh.sub(topic, async (topic: string, state: JobOutput) => {
         if (state.metadata.err) {
           const error = JSON.parse(state.metadata.err) as StreamError;
-          if (error.code === STATUS_CODE_INTERRUPT || !state.data) {
+          if (error.code === HMSH_CODE_INTERRUPT || !state.data) {
             return await complete(null, state.metadata.err);
           }
         }

package/services/durable/worker.ts

@@ -23,6 +23,7 @@ import {
   StreamData,
   StreamDataResponse,
   StreamStatus } from '../../types/stream';
+import { HMSH_LOGLEVEL } from '../../modules/enums';
 
 export class WorkerService {
   static activityRegistry: Registry = {}; //user's activities
@@ -36,7 +37,7 @@ export class WorkerService {
       return await WorkerService.instances.get(workflowTopic);
     }
     const hotMeshClient = HotMesh.init({
-      logLevel: options?.logLevel as 'debug' ?? 'info',
+      logLevel: options?.logLevel ?? HMSH_LOGLEVEL,
       appId: config.namespace ?? APP_ID,
       engine: { redis: { ...WorkerService.connection } }
     });
@@ -121,7 +122,7 @@ export class WorkerService {
       options: config.connection.options as RedisOptions
     };
     const hotMeshWorker = await HotMesh.init({
-      logLevel: config.options?.logLevel as 'debug' ?? 'info',
+      logLevel: config.options?.logLevel ?? HMSH_LOGLEVEL,
       appId: config.namespace ?? APP_ID,
       engine: { redis: redisConfig },
       workers: [
@@ -172,7 +173,7 @@ export class WorkerService {
       options: config.connection.options as RedisOptions
     };
     const hotMeshWorker = await HotMesh.init({
-      logLevel: config.options?.logLevel as 'debug' ?? 'info',
+      logLevel: config.options?.logLevel ?? HMSH_LOGLEVEL,
       appId: config.namespace ?? APP_ID,
       engine: { redis: redisConfig },
       workers: [{

package/services/engine/index.ts

@@ -1,10 +1,10 @@
 import { KeyType } from '../../modules/key';
 import {
-  OTT_WAIT_TIME,
-  STATUS_CODE_SUCCESS,
-  STATUS_CODE_PENDING,
-  STATUS_CODE_TIMEOUT, 
-  DURABLE_EXPIRE_SECONDS } from '../../modules/enums';
+  HMSH_OTT_WAIT_TIME,
+  HMSH_CODE_SUCCESS,
+  HMSH_CODE_PENDING,
+  HMSH_CODE_TIMEOUT, 
+  HMSH_EXPIRE_JOB_SECONDS } from '../../modules/enums';
 import {
   formatISODate,
   getSubscriptionTopic,
@@ -77,6 +77,7 @@ import {
   StreamError,
   StreamRole,
   StreamStatus } from '../../types/stream';
+import { WorkListTaskType } from '../../types/task';
 
 class EngineService {
   namespace: string;
@@ -438,10 +439,10 @@ class EngineService {
         streamData.code = error.code;
       } else if (emit) {
         streamData.status = StreamStatus.PENDING;
-        streamData.code = STATUS_CODE_PENDING;
+        streamData.code = HMSH_CODE_PENDING;
       } else {
         streamData.status = StreamStatus.SUCCESS;
-        streamData.code = STATUS_CODE_SUCCESS;
+        streamData.code = HMSH_CODE_SUCCESS;
       }
       return (await this.router?.publishMessage(null, streamData)) as string;
     }
@@ -489,7 +490,7 @@ class EngineService {
     };
     return await this.router.publishMessage(null, streamData) as string;
   }
-  async hookTime(jobId: string, gId: string, activityId: string, type?: 'sleep'|'expire'|'interrupt'): Promise<string | void> {
+  async hookTime(jobId: string, gId: string, activityId: string, type?: WorkListTaskType): Promise<string | void> {
     if (type === 'interrupt') {
       return await this.interrupt(
         activityId, //note: 'activityId' is the actually job topic
@@ -499,7 +500,6 @@ class EngineService {
     } else if (type === 'expire') {
       return await this.store.expireJob(jobId, 1);
     }
-    //'sleep': parse the activityId into parts
     const [aid, ...dimensions] = activityId.split(',');
     const dad = `,${dimensions.join(',')}`;
     const streamData: StreamData = {
@@ -575,7 +575,7 @@ class EngineService {
     return await this.subscribe.punsubscribe(KeyType.QUORUM, this.appId, wild);
   }
   //publish and await (returns the job and data (if ready)); throws error with jobid if not
-  async pubsub(topic: string, data: JobData, context?: JobState | null, timeout = OTT_WAIT_TIME): Promise<JobOutput> {
+  async pubsub(topic: string, data: JobData, context?: JobState | null, timeout = HMSH_OTT_WAIT_TIME): Promise<JobOutput> {
     context = {
       metadata: {
         ngn: this.guid,
@@ -597,9 +597,10 @@ class EngineService {
         }
       });
       setTimeout(() => {
+        //note: job is still active (the subscriber timed out)
         this.delistJobCallback(jobId);
         reject({
-          code: STATUS_CODE_TIMEOUT,
+          code: HMSH_CODE_TIMEOUT,
           message: 'timeout',
           job_id: jobId
         } as StreamError);
@@ -685,7 +686,7 @@ class EngineService {
    * it will be expired immediately.
    */
   resolveExpires(context: JobState, options: JobCompletionOptions): number {
-    return options.expire ?? context.metadata.expire ?? DURABLE_EXPIRE_SECONDS;
+    return options.expire ?? context.metadata.expire ?? HMSH_EXPIRE_JOB_SECONDS;
   }