@hotmeshio/hotmesh 0.0.12 → 0.0.14

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

@@ -18,6 +18,7 @@ declare class HotMeshService {
     verifyAndSetNamespace(namespace?: string): void;
     verifyAndSetAppId(appId: string): void;
     static init(config: HotMeshConfig): Promise<HotMeshService>;
+    static guid(): string;
     initEngine(config: HotMeshConfig, logger: ILogger): Promise<void>;
     initQuorum(config: HotMeshConfig, engine: EngineService, logger: ILogger): Promise<void>;
     initWorkers(config: HotMeshConfig, logger: ILogger): Promise<void>;
@@ -37,7 +38,7 @@ declare class HotMeshService {
     getIds(topic: string, query: JobStatsInput, queryFacets?: any[]): Promise<IdsResponse>;
     resolveQuery(topic: string, query: JobStatsInput): Promise<GetStatsOptions>;
     scrub(jobId: string): Promise<void>;
-    hook(topic: string, data: JobData, dad?: string): Promise<JobStatus | void>;
+    hook(topic: string, data: JobData, dad?: string): Promise<string>;
     hookAll(hookTopic: string, data: JobData, query: JobStatsInput, queryFacets?: string[]): Promise<string[]>;
     stop(): Promise<void>;
     compress(terms: string[]): Promise<boolean>;

package/build/services/hotmesh/index.js

@@ -48,6 +48,9 @@ class HotMeshService {
         await instance.initWorkers(config, instance.logger);
         return instance;
     }
+    static guid() {
+        return (0, nanoid_1.nanoid)();
+    }
     async initEngine(config, logger) {
         if (config.engine) {
             await connector_1.ConnectorService.initRedisClients(config.engine.redis?.class, config.engine.redis?.options, config.engine);
@@ -117,7 +120,6 @@ class HotMeshService {
     }
     // ****** `HOOK` ACTIVITY RE-ENTRY POINT ******
     async hook(topic, data, dad) {
-        //return collation int
         return await this.engine?.hook(topic, data, dad);
     }
     async hookAll(hookTopic, data, query, queryFacets = []) {

package/build/services/mapper/index.js

@@ -49,7 +49,7 @@ class MapperService {
         if (typeof transitionRule === 'boolean') {
             return transitionRule;
         }
-        if (code.toString() === (transitionRule.code || 200).toString()) {
+        if ((Array.isArray(transitionRule.code) && transitionRule.code.includes(code || 200)) || code.toString() === (transitionRule.code || 200).toString()) {
             if (!transitionRule.match) {
                 return true;
             }

package/build/services/pipe/functions/array.d.ts

@@ -1,5 +1,6 @@
 declare class ArrayHandler {
     get(array: any[], index: number): any;
+    length(array: any[]): any;
     concat(array1: any[], array2: any[]): any[];
     every(array: any[], callback: (value: any, index: number, array: any[]) => boolean): boolean;
     filter(array: any[], callback: (value: any, index: number, array: any[]) => boolean): any[];

package/build/services/pipe/functions/array.js

@@ -5,6 +5,9 @@ class ArrayHandler {
     get(array, index) {
         return array[index];
     }
+    length(array) {
+        return array?.length;
+    }
     concat(array1, array2) {
         return array1.concat(array2);
     }

package/build/services/reporter/index.js

@@ -20,12 +20,16 @@ class ReporterService {
         return statsResponse;
     }
     validateOptions(options) {
-        const { start, end, range } = options;
-        if (start && end && range || !start && !end && !range) {
+        const { start, end, range, granularity } = options;
+        if (granularity !== 'infinity' && (start && end && range || !start && !end && !range)) {
             throw new Error('Invalid combination of start, end, and range values. Provide either start+end, end+range, or start+range.');
         }
     }
     generateDateTimeSets(granularity, range, end, start) {
+        if (granularity === 'infinity') {
+            //if granularity is infinity, it means a date/time sequence/slice is not used to further segment the statistics
+            return ['0'];
+        }
         if (!range) {
             //pluck just a single value when no range provided
             range = '0m';
@@ -155,6 +159,9 @@ class ReporterService {
         return segments;
     }
     isoTimestampFromKeyTimestamp(hashKey) {
+        if (hashKey.endsWith(':')) {
+            return '0';
+        }
         const keyTimestamp = hashKey.slice(-12);
         const year = keyTimestamp.slice(0, 4);
         const month = keyTimestamp.slice(4, 6);

package/build/services/signaler/store.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.StoreSignaler = void 0;
+const pipe_1 = require("../pipe");
 class StoreSignaler {
     constructor(store, logger) {
         this.store = store;
@@ -13,10 +14,12 @@ class StoreSignaler {
     async registerWebHook(topic, context, multi) {
         const hookRule = await this.getHookRule(topic);
         if (hookRule) {
+            const mapExpression = hookRule.conditions.match[0].expected;
+            const resolved = pipe_1.Pipe.resolve(mapExpression, context);
             const jobId = context.metadata.jid;
             const hook = {
                 topic,
-                resolved: jobId,
+                resolved,
                 jobId,
             };
             await this.store.setHookSignal(hook, multi);
@@ -29,8 +32,10 @@ class StoreSignaler {
     async processWebHookSignal(topic, data) {
         const hookRule = await this.getHookRule(topic);
         if (hookRule) {
-            //todo: use the rule to generate `resolved`
-            const resolved = data.id;
+            //NOTE: both formats are supported: $self.hook.data OR $hook.data
+            const context = { $self: { hook: { data } }, $hook: { data } };
+            const mapExpression = hookRule.conditions.match[0].actual;
+            const resolved = pipe_1.Pipe.resolve(mapExpression, context);
             const jobId = await this.store.getHookSignal(topic, resolved);
             return jobId;
         }

package/build/services/signaler/stream.js

@@ -120,9 +120,9 @@ class StreamSignaler {
         try {
             output = await callback(input);
         }
-        catch (err) {
-            this.logger.error(`stream-call-function-error`, { stream, id, err });
-            output = this.structureUnhandledError(input, err);
+        catch (error) {
+            this.logger.error(`stream-call-function-error`, { error });
+            output = this.structureUnhandledError(input, error);
         }
         return output;
     }

package/build/services/store/clients/ioredis.js

@@ -51,45 +51,45 @@ class IORedisStoreService extends index_1.StoreService {
         try {
             return await (multi || this.redisClient).xadd(key, id, messageId, messageValue);
         }
-        catch (err) {
-            this.logger.error(`Error publishing 'xadd'; key: ${key}`, err);
-            throw err;
+        catch (error) {
+            this.logger.error(`Error publishing 'xadd'; key: ${key}`, { error });
+            throw error;
         }
     }
     async xpending(key, group, start, end, count, consumer) {
         try {
             return await this.redisClient.xpending(key, group, start, end, count, consumer);
         }
-        catch (err) {
-            this.logger.error(`Error in retrieving pending messages for [stream ${key}], [group ${group}]`, err);
-            throw err;
+        catch (error) {
+            this.logger.error(`Error in retrieving pending messages for [stream ${key}], [group ${group}]`, { error });
+            throw error;
         }
     }
     async xclaim(key, group, consumer, minIdleTime, id, ...args) {
         try {
             return await this.redisClient.xclaim(key, group, consumer, minIdleTime, id, ...args);
         }
-        catch (err) {
-            this.logger.error(`Error in claiming message with id: ${id} in group: ${group} for key: ${key}`, err);
-            throw err;
+        catch (error) {
+            this.logger.error(`Error in claiming message with id: ${id} in group: ${group} for key: ${key}`, { error });
+            throw error;
         }
     }
     async xack(key, group, id, multi) {
         try {
             return await (multi || this.redisClient).xack(key, group, id);
         }
-        catch (err) {
-            this.logger.error(`Error in acknowledging messages in group: ${group} for key: ${key}`, err);
-            throw err;
+        catch (error) {
+            this.logger.error(`Error in acknowledging messages in group: ${group} for key: ${key}`, { error });
+            throw error;
         }
     }
     async xdel(key, id, multi) {
         try {
             return await (multi || this.redisClient).xdel(key, id);
         }
-        catch (err) {
-            this.logger.error(`Error in deleting messages with id: ${id} for key: ${key}`, err);
-            throw err;
+        catch (error) {
+            this.logger.error(`Error in deleting messages with id: ${id} for key: ${key}`, { error });
+            throw error;
         }
     }
 }

package/build/services/store/clients/redis.js

@@ -63,10 +63,10 @@ class RedisStoreService extends index_1.StoreService {
         try {
             return (await this.redisClient.sendCommand(['XGROUP', 'CREATE', key, groupName, id, ...args])) === 1;
         }
-        catch (err) {
+        catch (error) {
             const streamType = mkStream === 'MKSTREAM' ? 'with MKSTREAM' : 'without MKSTREAM';
-            this.logger.warn(`x-group-error ${streamType} for key: ${key} and group: ${groupName}`, err);
-            throw err;
+            this.logger.warn(`x-group-error ${streamType} for key: ${key} and group: ${groupName}`, { error });
+            throw error;
         }
     }
     async xadd(key, id, ...args) {
@@ -77,9 +77,9 @@ class RedisStoreService extends index_1.StoreService {
         try {
             return await (multi || this.redisClient).XADD(key, id, { [args[0]]: args[1] });
         }
-        catch (err) {
-            this.logger.error(`Error publishing 'xadd'; key: ${key}`, err);
-            throw err;
+        catch (error) {
+            this.logger.error(`Error publishing 'xadd'; key: ${key}`, { error });
+            throw error;
         }
     }
     async xpending(key, group, start, end, count, consumer) {
@@ -95,18 +95,18 @@ class RedisStoreService extends index_1.StoreService {
                 args.push(consumer);
             return await this.redisClient.sendCommand(['XPENDING', ...args]);
         }
-        catch (err) {
-            this.logger.error(`Error in retrieving pending messages for group: ${group} in key: ${key}`, err);
-            throw err;
+        catch (error) {
+            this.logger.error(`Error in retrieving pending messages for group: ${group} in key: ${key}`, { error });
+            throw error;
         }
     }
     async xclaim(key, group, consumer, minIdleTime, id, ...args) {
         try {
             return await this.redisClient.sendCommand(['XCLAIM', key, group, consumer, minIdleTime.toString(), id, ...args]);
         }
-        catch (err) {
-            this.logger.error(`Error in claiming message with id: ${id} in group: ${group} for key: ${key}`, err);
-            throw err;
+        catch (error) {
+            this.logger.error(`Error in claiming message with id: ${id} in group: ${group} for key: ${key}`, { error });
+            throw error;
         }
     }
     async xack(key, group, id, multi) {
@@ -119,9 +119,9 @@ class RedisStoreService extends index_1.StoreService {
                 return await this.redisClient[this.commands.xack](key, group, id);
             }
         }
-        catch (err) {
-            this.logger.error(`Error in acknowledging messages in group: ${group} for key: ${key}`, err);
-            throw err;
+        catch (error) {
+            this.logger.error(`Error in acknowledging messages in group: ${group} for key: ${key}`, { error });
+            throw error;
         }
     }
     async xdel(key, id, multi) {
@@ -134,9 +134,9 @@ class RedisStoreService extends index_1.StoreService {
                 return await this.redisClient[this.commands.xdel](key, id);
             }
         }
-        catch (err) {
-            this.logger.error(`Error in deleting messages with ids: ${id} for key: ${key}`, err);
-            throw err;
+        catch (error) {
+            this.logger.error(`Error in deleting messages with ids: ${id} for key: ${key}`, { error });
+            throw error;
         }
     }
 }

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

@@ -78,7 +78,7 @@ declare abstract class StoreService<T, U extends AbstractRedisClient> {
     deleteHookSignal(topic: string, resolved: string): Promise<number | undefined>;
     addTaskQueues(keys: string[]): Promise<void>;
     getActiveTaskQueue(): Promise<string | null>;
-    deleteProcessedTaskQueue(workItemKey: string, key: string, processedKey: string): Promise<void>;
+    deleteProcessedTaskQueue(workItemKey: string, key: string, processedKey: string, scrub?: boolean): Promise<void>;
     processTaskQueue(sourceKey: string, destinationKey: string): Promise<any>;
     expireJob(jobId: string, inSeconds: number): Promise<void>;
     registerTimeHook(jobId: string, activityId: string, type: 'sleep' | 'expire' | 'cron', deletionTime: number, multi?: U): Promise<void>;

package/build/services/store/index.js

@@ -355,7 +355,8 @@ class StoreService {
         const output = {};
         for (const [index, result] of results.entries()) {
             const key = indexKeys[index];
-            const idsList = result[1];
+            //todo: resolve this discrepancy between redis/ioredis
+            const idsList = result[1] || result;
             if (idsList && idsList.length > 0) {
                 output[key] = idsList;
             }
@@ -601,11 +602,18 @@ class StoreService {
         }
         return workItemKey;
     }
-    async deleteProcessedTaskQueue(workItemKey, key, processedKey) {
+    async deleteProcessedTaskQueue(workItemKey, key, processedKey, scrub = false) {
         const zsetKey = this.mintKey(key_1.KeyType.WORK_ITEMS, { appId: this.appId });
         const didRemove = await this.redisClient[this.commands.zrem](zsetKey, workItemKey);
         if (didRemove) {
-            await this.redisClient[this.commands.rename](processedKey, key);
+            if (scrub) {
+                //indexes can be designed to be self-cleaning; `engine.hookAll` exposes this option
+                this.redisClient[this.commands.expire](processedKey, 0);
+                this.redisClient[this.commands.expire](key.split(":").slice(0, 5).join(":"), 0);
+            }
+            else {
+                await this.redisClient[this.commands.rename](processedKey, key);
+            }
         }
         this.cache.removeWorkItem(this.appId);
     }

package/build/services/task/index.js

@@ -15,16 +15,16 @@ class TaskService {
     async processWebHooks(hookEventCallback) {
         const workItemKey = await this.store.getActiveTaskQueue();
         if (workItemKey) {
-            const [topic, sourceKey, ...sdata] = workItemKey.split('::');
+            const [topic, sourceKey, scrub, ...sdata] = workItemKey.split('::');
             const data = JSON.parse(sdata.join('::'));
             const destinationKey = `${sourceKey}:processed`;
             const jobId = await this.store.processTaskQueue(sourceKey, destinationKey);
             if (jobId) {
+                //todo: don't use 'id', make configurable using hook rule
                 await hookEventCallback(topic, { ...data, id: jobId });
-                //todo: do final checksum count (values are tracked in the stats hash)
             }
             else {
-                await this.store.deleteProcessedTaskQueue(workItemKey, sourceKey, destinationKey);
+                await this.store.deleteProcessedTaskQueue(workItemKey, sourceKey, destinationKey, scrub === 'true');
             }
             setImmediate(() => this.processWebHooks(hookEventCallback));
         }

package/build/types/activity.d.ts

@@ -1,6 +1,6 @@
 import { MetricTypes } from "./stats";
 import { StreamRetryPolicy } from "./stream";
-type ActivityExecutionType = 'trigger' | 'await' | 'worker' | 'activity' | 'emit' | 'iterate' | 'cycle';
+type ActivityExecutionType = 'trigger' | 'await' | 'worker' | 'activity' | 'emit' | 'iterate' | 'cycle' | 'signal';
 type Consumes = Record<string, string[]>;
 interface BaseActivity {
     title?: string;
@@ -12,6 +12,7 @@ interface BaseActivity {
     job?: Record<string, any>;
     hook?: Record<string, any>;
     telemetry?: Record<string, any>;
+    emit?: boolean;
     sleep?: number;
     expire?: number;
     retry?: StreamRetryPolicy;
@@ -37,6 +38,7 @@ interface TriggerActivityStats {
     key?: {
         [key: string]: unknown;
     } | string;
+    granularity?: string;
     measures?: Measure[];
 }
 interface TriggerActivity extends BaseActivity {
@@ -53,17 +55,24 @@ interface WorkerActivity extends BaseActivity {
     topic: string;
     timeout: number;
 }
-interface EmitActivity extends BaseActivity {
-    type: 'emit';
-}
 interface CycleActivity extends BaseActivity {
     type: 'cycle';
     ancestor: string;
 }
+interface SignalActivity extends BaseActivity {
+    type: 'signal';
+    subtype: 'one' | 'all';
+    topic: string;
+    key_name: string;
+    key_value: string;
+    scrub: boolean;
+    signal?: Record<string, any>;
+    resolver?: Record<string, any>;
+}
 interface IterateActivity extends BaseActivity {
     type: 'iterate';
 }
-type ActivityType = BaseActivity | TriggerActivity | AwaitActivity | WorkerActivity | EmitActivity | IterateActivity;
+type ActivityType = BaseActivity | TriggerActivity | AwaitActivity | WorkerActivity | IterateActivity;
 type ActivityData = Record<string, any>;
 type ActivityMetadata = {
     aid: string;
@@ -89,4 +98,4 @@ type ActivityDataType = {
     hook?: Record<string, unknown>;
 };
 type ActivityLeg = 1 | 2;
-export { ActivityContext, ActivityData, ActivityDataType, ActivityDuplex, ActivityLeg, ActivityMetadata, ActivityType, Consumes, TriggerActivityStats, AwaitActivity, CycleActivity, BaseActivity, EmitActivity, IterateActivity, TriggerActivity, WorkerActivity };
+export { ActivityContext, ActivityData, ActivityDataType, ActivityDuplex, ActivityLeg, ActivityMetadata, ActivityType, Consumes, TriggerActivityStats, AwaitActivity, CycleActivity, SignalActivity, BaseActivity, IterateActivity, TriggerActivity, WorkerActivity };

package/build/types/durable.d.ts

@@ -1,4 +1,10 @@
 import { RedisClass, RedisOptions } from './redis';
+type WorkflowConfig = {
+    backoffCoefficient?: number;
+    maximumAttempts?: number;
+    maximumInterval?: string;
+    initialInterval?: string;
+};
 type WorkflowOptions = {
     taskQueue: string;
     args: any[];
@@ -6,6 +12,13 @@ type WorkflowOptions = {
     workflowName?: string;
     workflowTrace?: string;
     workflowSpan?: string;
+    config?: WorkflowConfig;
+};
+type SignalOptions = {
+    taskQueue: string;
+    data: Record<string, any>;
+    workflowId: string;
+    workflowName?: string;
 };
 type ActivityWorkflowDataType = {
     activityName: string;
@@ -39,7 +52,7 @@ type WorkerConfig = {
 };
 type WorkerOptions = {
     maxSystemRetries?: number;
-    backoffExponent?: number;
+    backoffCoefficient?: number;
 };
 type ContextType = {
     workflowId: string;
@@ -59,4 +72,4 @@ type ActivityConfig = {
         maximumInterval: string;
     };
 };
-export { ActivityConfig, ActivityWorkflowDataType, ClientConfig, ContextType, ConnectionConfig, Connection, NativeConnection, ProxyType, Registry, WorkerConfig, WorkerOptions, WorkflowDataType, WorkflowOptions, };
+export { ActivityConfig, ActivityWorkflowDataType, ClientConfig, ContextType, ConnectionConfig, Connection, NativeConnection, ProxyType, Registry, SignalOptions, WorkerConfig, WorkflowConfig, WorkerOptions, WorkflowDataType, WorkflowOptions, };

package/build/types/index.d.ts

@@ -1,9 +1,9 @@
-export { ActivityType, ActivityDataType, ActivityContext, ActivityData, ActivityDuplex, ActivityLeg, ActivityMetadata, Consumes, AwaitActivity, BaseActivity, CycleActivity, EmitActivity, WorkerActivity, IterateActivity, TriggerActivity, TriggerActivityStats } from './activity';
+export { ActivityType, ActivityDataType, ActivityContext, ActivityData, ActivityDuplex, ActivityLeg, ActivityMetadata, Consumes, AwaitActivity, BaseActivity, CycleActivity, WorkerActivity, IterateActivity, SignalActivity, TriggerActivity, TriggerActivityStats } from './activity';
 export { App, AppVID, AppTransitions, AppSubscriptions } from './app';
 export { AsyncSignal } from './async';
 export { CacheMode } from './cache';
 export { CollationFaultType, CollationStage } from './collator';
-export { ActivityConfig, ActivityWorkflowDataType, ClientConfig, ContextType, ConnectionConfig, Connection, NativeConnection, ProxyType, Registry, WorkerConfig, WorkerOptions, WorkflowDataType, WorkflowOptions, } from './durable';
+export { ActivityConfig, ActivityWorkflowDataType, ClientConfig, ContextType, ConnectionConfig, Connection, NativeConnection, ProxyType, Registry, WorkflowConfig, WorkerConfig, WorkerOptions, WorkflowDataType, WorkflowOptions, } from './durable';
 export { HookCondition, HookConditions, HookGate, HookInterface, HookRule, HookRules, HookSignal } from './hook';
 export { RedisClientType as IORedisClientType, RedisMultiType as IORedisMultiType } from './ioredisclient';
 export { ILogger } from './logger';

package/build/types/stats.d.ts

@@ -32,6 +32,7 @@ interface JobStatsInput {
     start?: string;
     end?: string;
     sparse?: boolean;
+    scrub?: boolean;
 }
 interface GetStatsOptions {
     key: string;

package/modules/errors.ts

@@ -12,6 +12,38 @@ class SetStateError extends Error {
   }
 }
 
+//thrown when a signal set is incomplete but already configured
+//if a waitFor set has 'n' items, this can be thrown `n - 1` times
+class DurableIncompleteSignalError extends Error {
+  code: number;
+  constructor(message: string) {
+    super(message);
+    this.code = 593;
+  }
+}
+
+//the original waitFor error that is thrown for a new signal set
+class DurableWaitForSignalError extends Error {
+  code: number;
+  signals: {signal: string, index: number}[]; //signal id and execution order in the workflow
+  constructor(message: string, signals: {signal: string, index: number}[]) {
+    super(message);
+    this.signals = signals;
+    this.code = 594;
+  }
+}
+
+class DurableSleepError extends Error {
+  code: number;
+  duration: number; //seconds
+  index: number;    //execution order in the workflow 
+  constructor(message: string, duration: number, index: number) {
+    super(message);
+    this.duration = duration;
+    this.index = index;
+    this.code = 595;
+  }
+}
 class DurableTimeoutError extends Error {
   code: number;
   constructor(message: string) {
@@ -87,6 +119,9 @@ export {
   DurableMaxedError,
   DurableFatalError,
   DurableRetryError,
+  DurableWaitForSignalError,
+  DurableIncompleteSignalError,
+  DurableSleepError,
   DuplicateJobError,
   GetStateError,
   SetStateError,

package/modules/utils.ts

@@ -86,9 +86,13 @@ export async function getSubscriptionTopic(activityId: string, store: StoreServi
 }
 
 /**
- * returns the 12-digit format of the iso timestamp (e.g, 202101010000)
+ * returns the 12-digit format of the iso timestamp (e.g, 202101010000); returns
+ * an empty string if overridden by the user to not segment by time (infinity).
  */
 export function getTimeSeries(granularity: string): string {
+  if (granularity.toString() === 'infinity') {
+    return '0';
+  }
   const now = new Date();
   const granularityUnit = granularity.slice(-1);
   const granularityValue = parseInt(granularity.slice(0, -1), 10);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@hotmeshio/hotmesh",
-  "version": "0.0.12",
-  "description": "Durable Workflows",
+  "version": "0.0.14",
+  "description": "Unbreakable Workflows",
   "main": "build/index.js",
   "types": "build/index.d.ts",
   "repository": {
@@ -26,6 +26,9 @@
     "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:emit": "NODE_ENV=test jest ./tests/functional/emit/index.test.ts --detectOpenHandles --forceExit --verbose",
+    "test:hook": "NODE_ENV=test jest ./tests/functional/hook/index.test.ts --detectOpenHandles --forceExit --verbose",
+    "test:signal": "NODE_ENV=test jest ./tests/functional/signal/index.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",
@@ -44,6 +47,8 @@
     "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:fatal": "NODE_ENV=test jest ./tests/durable/fatal/index.test.ts --detectOpenHandles --forceExit --verbose",
+    "test:durable:sleep": "NODE_ENV=test jest ./tests/durable/sleep/index.test.ts --detectOpenHandles --forceExit --verbose",
+    "test:durable:signal": "NODE_ENV=test jest ./tests/durable/signal/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"
   },

package/services/activities/activity.ts

@@ -30,6 +30,7 @@ import {
   StreamDataType,
   StreamStatus } from '../../types/stream';
 import { TransitionRule } from '../../types/transition';
+import { HookRule } from '../../types/hook';
 
 /**
  * The base class for all activities
@@ -114,9 +115,9 @@ class Activity {
       return this.context.metadata.aid;
     } catch (error) {
       if (error instanceof GetStateError) {
-        this.logger.error('activity-get-state-error', error);
+        this.logger.error('activity-get-state-error', { error });
       } else {
-        this.logger.error('activity-process-error', error);
+        this.logger.error('activity-process-error', { error });
       }
       telemetry.setActivityError(error.message);
       throw error;
@@ -135,6 +136,11 @@ class Activity {
     return !!(this.config.hook?.topic || this.config.sleep);
   }
 
+  async getHookRule(topic: string): Promise<HookRule | undefined> {
+    const rules = await this.store.getHookRules();
+    return rules?.[topic]?.[0] as HookRule;
+  }
+
   async registerHook(multi?: RedisMulti): Promise<string | void> {
     if (this.config.hook?.topic) {
       const signaler = new StoreSignaler(this.store, this.logger);
@@ -203,7 +209,7 @@ class Activity {
       telemetry.setActivityAttributes(attrs);
       return jobStatus as number;
     } catch (error) {
-      this.logger.error('engine-process-hook-event-error', error);
+      this.logger.error('engine-process-hook-event-error', { error });
       telemetry.setActivityError(error.message);
       throw error;
     } finally {
@@ -245,11 +251,11 @@ class Activity {
       }
       this.transitionAdjacent(multiResponse, telemetry);
     } catch (error) {
-      this.logger.error('activity-process-event-error', error);
-      telemetry.setActivityError(error.message);
+      this.logger.error('activity-process-event-error', { error });
+      telemetry && telemetry.setActivityError(error.message);
       throw error;
     } finally {
-      telemetry.endActivitySpan();
+      telemetry && telemetry.endActivitySpan();
       this.logger.debug('activity-process-event-end', { jid, aid });
     }
   }
@@ -570,14 +576,18 @@ class Activity {
 
   async transition(adjacencyList: StreamData[], jobStatus: JobStatus): Promise<string[]> {
     let mIds: string[] = [];
-    if (adjacencyList.length) {
+     if (jobStatus <= 0 || this.config.emit) {
+      //activity should not send 'emit' if the job is truly over
+      const isTrueEmit = jobStatus > 0;
+      await this.engine.runJobCompletionTasks(this.context, isTrueEmit);
+    }
+
+    if (adjacencyList.length && jobStatus > 0) {
       const multi = this.store.getMulti();
       for (const execSignal of adjacencyList) {
         await this.engine.streamSignaler?.publishMessage(null, execSignal, multi);
       }
       mIds = (await multi.exec()) as string[];
-    } else if (jobStatus <= 0) {
-      await this.engine.runJobCompletionTasks(this.context);
     }
     return mIds;
   }