@hotmeshio/hotmesh 0.0.12 → 0.0.13

package/README.md

@@ -161,10 +161,10 @@ const jobId = await hotMesh.pub(topic, payload);
 ```
 
 ### Subscribe to Events
-Call `sub` to subscribe to all workflow results for a given topic.
+Call `psub` (patterned subscription) to subscribe to all workflow results for a given topic.
 
 ```javascript
-await hotMesh.sub('sandbox.work.done', (topic, jobOutput) => {
+await hotMesh.psub('sandbox.work.done.*', (topic, jobOutput) => {
   // use jobOutput.data
 });
 ```

package/build/modules/errors.d.ts

@@ -6,6 +6,27 @@ declare class GetStateError extends Error {
 declare class SetStateError extends Error {
     constructor();
 }
+declare class DurableIncompleteSignalError extends Error {
+    code: number;
+    constructor(message: string);
+}
+declare class DurableWaitForSignalError extends Error {
+    code: number;
+    signals: {
+        signal: string;
+        index: number;
+    }[];
+    constructor(message: string, signals: {
+        signal: string;
+        index: number;
+    }[]);
+}
+declare class DurableSleepError extends Error {
+    code: number;
+    duration: number;
+    index: number;
+    constructor(message: string, duration: number, index: number);
+}
 declare class DurableTimeoutError extends Error {
     code: number;
     constructor(message: string);
@@ -41,4 +62,4 @@ declare class CollationError extends Error {
     fault: CollationFaultType;
     constructor(status: number, leg: ActivityDuplex, stage: CollationStage, fault?: CollationFaultType);
 }
-export { CollationError, DurableTimeoutError, DurableMaxedError, DurableFatalError, DurableRetryError, DuplicateJobError, GetStateError, SetStateError, MapDataError, RegisterTimeoutError, ExecActivityError };
+export { CollationError, DurableTimeoutError, DurableMaxedError, DurableFatalError, DurableRetryError, DurableWaitForSignalError, DurableIncompleteSignalError, DurableSleepError, DuplicateJobError, GetStateError, SetStateError, MapDataError, RegisterTimeoutError, ExecActivityError };

package/build/modules/errors.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ExecActivityError = exports.RegisterTimeoutError = exports.MapDataError = exports.SetStateError = exports.GetStateError = exports.DuplicateJobError = exports.DurableRetryError = exports.DurableFatalError = exports.DurableMaxedError = exports.DurableTimeoutError = exports.CollationError = void 0;
+exports.ExecActivityError = exports.RegisterTimeoutError = exports.MapDataError = exports.SetStateError = exports.GetStateError = exports.DuplicateJobError = exports.DurableSleepError = exports.DurableIncompleteSignalError = exports.DurableWaitForSignalError = exports.DurableRetryError = exports.DurableFatalError = exports.DurableMaxedError = exports.DurableTimeoutError = exports.CollationError = void 0;
 class GetStateError extends Error {
     constructor() {
         super("Error occurred while getting job state");
@@ -13,6 +13,33 @@ class SetStateError extends Error {
     }
 }
 exports.SetStateError = SetStateError;
+//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 {
+    constructor(message) {
+        super(message);
+        this.code = 593;
+    }
+}
+exports.DurableIncompleteSignalError = DurableIncompleteSignalError;
+//the original waitFor error that is thrown for a new signal set
+class DurableWaitForSignalError extends Error {
+    constructor(message, signals) {
+        super(message);
+        this.signals = signals;
+        this.code = 594;
+    }
+}
+exports.DurableWaitForSignalError = DurableWaitForSignalError;
+class DurableSleepError extends Error {
+    constructor(message, duration, index) {
+        super(message);
+        this.duration = duration;
+        this.index = index;
+        this.code = 595;
+    }
+}
+exports.DurableSleepError = DurableSleepError;
 class DurableTimeoutError extends Error {
     constructor(message) {
         super(message);

package/build/modules/utils.d.ts

@@ -21,7 +21,8 @@ export declare function findSubscriptionForTrigger(obj: AppSubscriptions, value:
  */
 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)
+ * 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 declare function getTimeSeries(granularity: string): string;
 export declare function formatISODate(input: Date | string): string;

package/build/modules/utils.js

@@ -85,9 +85,13 @@ async function getSubscriptionTopic(activityId, store, appVID) {
 }
 exports.getSubscriptionTopic = getSubscriptionTopic;
 /**
- * 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).
  */
 function getTimeSeries(granularity) {
+    if (granularity.toString() === 'infinity') {
+        return '0';
+    }
     const now = new Date();
     const granularityUnit = granularity.slice(-1);
     const granularityValue = parseInt(granularity.slice(0, -1), 10);

package/build/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@hotmeshio/hotmesh",
-    "version": "0.0.12",
-    "description": "Durable Workflows",
+    "version": "0.0.13",
+    "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/build/services/activities/activity.d.ts

@@ -7,6 +7,7 @@ import { JobState, JobStatus } from '../../types/job';
 import { MultiResponseFlags, RedisClient, RedisMulti } from '../../types/redis';
 import { StringAnyType } from '../../types/serializer';
 import { StreamCode, StreamData, StreamStatus } from '../../types/stream';
+import { HookRule } from '../../types/hook';
 /**
  * The base class for all activities
  */
@@ -28,6 +29,7 @@ declare class Activity {
     process(): Promise<string>;
     setLeg(leg: ActivityLeg): void;
     doesHook(): boolean;
+    getHookRule(topic: string): Promise<HookRule | undefined>;
     registerHook(multi?: RedisMulti): Promise<string | void>;
     processWebHookEvent(): Promise<JobStatus | void>;
     processTimeHookEvent(jobId: string): Promise<JobStatus | void>;

package/build/services/activities/activity.js

@@ -72,10 +72,10 @@ class Activity {
         }
         catch (error) {
             if (error instanceof errors_1.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;
@@ -92,6 +92,10 @@ class Activity {
     doesHook() {
         return !!(this.config.hook?.topic || this.config.sleep);
     }
+    async getHookRule(topic) {
+        const rules = await this.store.getHookRules();
+        return rules?.[topic]?.[0];
+    }
     async registerHook(multi) {
         if (this.config.hook?.topic) {
             const signaler = new store_1.StoreSignaler(this.store, this.logger);
@@ -155,7 +159,7 @@ class Activity {
             return jobStatus;
         }
         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;
         }
@@ -197,12 +201,12 @@ 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 });
         }
     }
@@ -484,16 +488,18 @@ class Activity {
     }
     async transition(adjacencyList, jobStatus) {
         let mIds = [];
-        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());
         }
-        else if (jobStatus <= 0) {
-            await this.engine.runJobCompletionTasks(this.context);
-        }
         return mIds;
     }
 }

package/build/services/activities/await.d.ts

@@ -2,15 +2,11 @@ import { Activity } from './activity';
 import { EngineService } from '../engine';
 import { ActivityData, ActivityMetadata, AwaitActivity, ActivityType } from '../../types/activity';
 import { JobState } from '../../types/job';
-import { MultiResponseFlags } from '../../types/redis';
-import { StreamCode, StreamData, StreamStatus } from '../../types/stream';
+import { RedisMulti } from '../../types/redis';
 declare class Await extends Activity {
     config: AwaitActivity;
     constructor(config: ActivityType, data: ActivityData, metadata: ActivityMetadata, hook: ActivityData | null, engine: EngineService, context?: JobState);
     process(): Promise<string>;
-    execActivity(): Promise<string>;
-    processEvent(status?: StreamStatus, code?: StreamCode): Promise<void>;
-    processSuccessResponse(adjacencyList: StreamData[]): Promise<MultiResponseFlags>;
-    processErrorResponse(adjacencyList: StreamData[]): Promise<MultiResponseFlags>;
+    execActivity(multi: RedisMulti): Promise<string>;
 }
 export { Await };

package/build/services/activities/await.js

@@ -3,9 +3,10 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Await = void 0;
 const errors_1 = require("../../modules/errors");
 const activity_1 = require("./activity");
+const collator_1 = require("../collator");
 const stream_1 = require("../../types/stream");
 const telemetry_1 = require("../telemetry");
-const collator_1 = require("../collator");
+const pipe_1 = require("../pipe");
 class Await extends activity_1.Activity {
     constructor(config, data, metadata, hook, engine, context) {
         super(config, data, metadata, hook, engine, context);
@@ -15,21 +16,24 @@ class Await extends activity_1.Activity {
         this.logger.debug('await-process', { jid: this.context.metadata.jid, aid: this.metadata.aid });
         let telemetry;
         try {
+            //confirm entry is allowed and restore state
             this.setLeg(1);
             await collator_1.CollatorService.notarizeEntry(this);
             await this.getState();
             telemetry = new telemetry_1.TelemetryService(this.engine.appId, this.config, this.metadata, this.context);
             telemetry.startActivitySpan(this.leg);
             this.mapInputData();
+            //save state and authorize reentry
             const multi = this.store.getMulti();
             //todo: await this.registerTimeout();
+            const messageId = await this.execActivity(multi);
             await collator_1.CollatorService.authorizeReentry(this, multi);
             await this.setState(multi);
             await this.setStatus(0, multi);
             const multiResponse = await multi.exec();
+            //telemetry
             telemetry.mapActivityAttributes();
             const jobStatus = this.resolveStatus(multiResponse);
-            const messageId = await this.execActivity();
             telemetry.setActivityAttributes({
                 'app.activity.mid': messageId,
                 'app.job.jss': jobStatus
@@ -39,10 +43,10 @@ class Await extends activity_1.Activity {
         catch (error) {
             telemetry.setActivityError(error.message);
             if (error instanceof errors_1.GetStateError) {
-                this.logger.error('await-get-state-error', error);
+                this.logger.error('await-get-state-error', { error });
             }
             else {
-                this.logger.error('await-process-error', error);
+                this.logger.error('await-process-error', { error });
             }
             throw error;
         }
@@ -51,13 +55,14 @@ class Await extends activity_1.Activity {
             this.logger.debug('await-process-end', { jid: this.context.metadata.jid, aid: this.metadata.aid });
         }
     }
-    async execActivity() {
+    async execActivity(multi) {
+        const topic = pipe_1.Pipe.resolve(this.config.subtype, this.context);
         const streamData = {
             metadata: {
                 jid: this.context.metadata.jid,
                 dad: this.metadata.dad,
                 aid: this.metadata.aid,
-                topic: this.config.subtype,
+                topic,
                 spn: this.context['$self'].output.metadata?.l1s,
                 trc: this.context.metadata.trc,
             },
@@ -69,75 +74,7 @@ class Await extends activity_1.Activity {
                 retry: this.config.retry
             };
         }
-        return (await this.engine.streamSignaler?.publishMessage(null, streamData));
-    }
-    //********  `RESOLVE` ENTRY POINT (B)  ********//
-    //this method is invoked when the job spawned by this job ends;
-    //`this.data` is the job data produced by the spawned job
-    async processEvent(status = stream_1.StreamStatus.SUCCESS, code = 200) {
-        this.setLeg(2);
-        const jid = this.context.metadata.jid;
-        const aid = this.metadata.aid;
-        if (!jid) {
-            throw new Error('await-process-event-error');
-        }
-        this.logger.debug('await-resolve-await', { jid, aid, status, code });
-        this.status = status;
-        this.code = code;
-        let telemetry;
-        try {
-            await this.getState();
-            const aState = await collator_1.CollatorService.notarizeReentry(this);
-            this.adjacentIndex = collator_1.CollatorService.getDimensionalIndex(aState);
-            telemetry = new telemetry_1.TelemetryService(this.engine.appId, this.config, this.metadata, this.context);
-            telemetry.startActivitySpan(this.leg);
-            let multiResponse = [];
-            if (status === stream_1.StreamStatus.SUCCESS) {
-                this.bindActivityData('output');
-                this.adjacencyList = await this.filterAdjacent();
-                multiResponse = await this.processSuccessResponse(this.adjacencyList);
-            }
-            else {
-                this.bindActivityError(this.data);
-                this.adjacencyList = await this.filterAdjacent();
-                multiResponse = await this.processErrorResponse(this.adjacencyList);
-            }
-            telemetry.mapActivityAttributes();
-            const jobStatus = this.resolveStatus(multiResponse);
-            const attrs = { 'app.job.jss': jobStatus };
-            const messageIds = await this.transition(this.adjacencyList, jobStatus);
-            if (messageIds.length) {
-                attrs['app.activity.mids'] = messageIds.join(',');
-            }
-            telemetry.setActivityAttributes(attrs);
-        }
-        catch (error) {
-            this.logger.error('await-resolve-await-error', error);
-            telemetry.setActivityError(error.message);
-            throw error;
-        }
-        finally {
-            telemetry.endActivitySpan();
-            this.logger.debug('await-resolve-await-end', { jid, aid, status, code });
-        }
-    }
-    async processSuccessResponse(adjacencyList) {
-        this.mapJobData();
-        const multi = this.store.getMulti();
-        await this.setState(multi);
-        await collator_1.CollatorService.notarizeCompletion(this, multi);
-        await this.setStatus(adjacencyList.length - 1, multi);
-        return await multi.exec();
-    }
-    async processErrorResponse(adjacencyList) {
-        //todo: if adjacencyList.length == 0, then map to the job output
-        //      this method would be added to Base activity class 
-        //this.mapJobData();
-        const multi = this.store.getMulti();
-        await this.setState(multi);
-        await collator_1.CollatorService.notarizeCompletion(this, multi);
-        await this.setStatus(adjacencyList.length - 1, multi);
-        return await multi.exec();
+        return (await this.engine.streamSignaler?.publishMessage(null, streamData, multi));
     }
 }
 exports.Await = Await;

package/build/services/activities/cycle.js

@@ -42,10 +42,10 @@ class Cycle extends activity_1.Activity {
         }
         catch (error) {
             if (error instanceof errors_1.GetStateError) {
-                this.logger.error('cycle-get-state-error', error);
+                this.logger.error('cycle-get-state-error', { error });
             }
             else {
-                this.logger.error('cycle-process-error', error);
+                this.logger.error('cycle-process-error', { error });
             }
             telemetry.setActivityError(error.message);
             throw error;

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

@@ -1,8 +1,8 @@
 import { Activity } from './activity';
 import { Await } from './await';
 import { Cycle } from './cycle';
-import { Emit } from './emit';
 import { Iterate } from './iterate';
+import { Signal } from './signal';
 import { Trigger } from './trigger';
 import { Worker } from './worker';
 declare const _default: {
@@ -10,7 +10,7 @@ declare const _default: {
     await: typeof Await;
     cycle: typeof Cycle;
     iterate: typeof Iterate;
-    emit: typeof Emit;
+    signal: typeof Signal;
     trigger: typeof Trigger;
     worker: typeof Worker;
 };

package/build/services/activities/index.js

@@ -3,8 +3,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const activity_1 = require("./activity");
 const await_1 = require("./await");
 const cycle_1 = require("./cycle");
-const emit_1 = require("./emit");
 const iterate_1 = require("./iterate");
+const signal_1 = require("./signal");
 const trigger_1 = require("./trigger");
 const worker_1 = require("./worker");
 exports.default = {
@@ -12,7 +12,7 @@ exports.default = {
     await: await_1.Await,
     cycle: cycle_1.Cycle,
     iterate: iterate_1.Iterate,
-    emit: emit_1.Emit,
+    signal: signal_1.Signal,
     trigger: trigger_1.Trigger,
     worker: worker_1.Worker,
 };

package/build/services/activities/signal.d.ts

@@ -0,0 +1,16 @@
+import { Activity, ActivityType } from './activity';
+import { EngineService } from '../engine';
+import { ActivityData, ActivityMetadata, SignalActivity } from '../../types/activity';
+import { JobState } from '../../types/job';
+declare class Signal extends Activity {
+    config: SignalActivity;
+    constructor(config: ActivityType, data: ActivityData, metadata: ActivityMetadata, hook: ActivityData | null, engine: EngineService, context?: JobState);
+    process(): Promise<string>;
+    mapSignalData(): Record<string, any>;
+    mapResolverData(): Record<string, any>;
+    /**
+     * The signal activity will hook all paused jobs that share the same job key.
+     */
+    hookAll(): Promise<string[]>;
+}
+export { Signal };

package/build/services/activities/signal.js

@@ -0,0 +1,94 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Signal = void 0;
+const errors_1 = require("../../modules/errors");
+const activity_1 = require("./activity");
+const collator_1 = require("../collator");
+const mapper_1 = require("../mapper");
+const pipe_1 = require("../pipe");
+const telemetry_1 = require("../telemetry");
+class Signal extends activity_1.Activity {
+    constructor(config, data, metadata, hook, engine, context) {
+        super(config, data, metadata, hook, engine, context);
+    }
+    //********  LEG 1 ENTRY  ********//
+    async process() {
+        this.logger.debug('signal-process', { jid: this.context.metadata.jid, aid: this.metadata.aid });
+        let telemetry;
+        try {
+            //verify entry is allowed
+            this.setLeg(1);
+            await collator_1.CollatorService.notarizeEntry(this);
+            await this.getState();
+            telemetry = new telemetry_1.TelemetryService(this.engine.appId, this.config, this.metadata, this.context);
+            telemetry.startActivitySpan(this.leg);
+            //save state and notarize early completion (signals only run leg1)
+            const multi = this.store.getMulti();
+            this.adjacencyList = await this.filterAdjacent();
+            this.mapOutputData();
+            this.mapJobData();
+            await this.setState(multi);
+            await collator_1.CollatorService.notarizeEarlyCompletion(this, multi);
+            await this.setStatus(this.adjacencyList.length - 1, multi);
+            const multiResponse = await multi.exec();
+            //signal to awaken all paused jobs that share the targeted job key
+            await this.hookAll();
+            //transition to adjacent activities
+            const jobStatus = this.resolveStatus(multiResponse);
+            const attrs = { 'app.job.jss': jobStatus };
+            const messageIds = await this.transition(this.adjacencyList, jobStatus);
+            if (messageIds.length) {
+                attrs['app.activity.mids'] = messageIds.join(',');
+            }
+            telemetry.mapActivityAttributes();
+            telemetry.setActivityAttributes(attrs);
+            return this.context.metadata.aid;
+        }
+        catch (error) {
+            if (error instanceof errors_1.GetStateError) {
+                this.logger.error('signal-get-state-error', { error });
+            }
+            else {
+                this.logger.error('signal-process-error', { error });
+            }
+            telemetry.setActivityError(error.message);
+            throw error;
+        }
+        finally {
+            telemetry.endActivitySpan();
+            this.logger.debug('signal-process-end', { jid: this.context.metadata.jid, aid: this.metadata.aid });
+        }
+    }
+    mapSignalData() {
+        if (this.config.signal?.maps) {
+            const mapper = new mapper_1.MapperService(this.config.signal.maps, this.context);
+            return mapper.mapRules();
+        }
+    }
+    mapResolverData() {
+        if (this.config.resolver?.maps) {
+            const mapper = new mapper_1.MapperService(this.config.resolver.maps, this.context);
+            return mapper.mapRules();
+        }
+    }
+    /**
+     * The signal activity will hook all paused jobs that share the same job key.
+     */
+    async hookAll() {
+        //prep 1) generate `input signal data` (essentially the webhook payload)
+        const signalInputData = this.mapSignalData();
+        //prep 2) generate data that resolves the job key (per the YAML config)
+        const keyResolverData = this.mapResolverData();
+        if (this.config.scrub) {
+            //self-clean the indexes upon use if configured
+            keyResolverData.scrub = true;
+        }
+        //prep 3) jobKeys can contain multiple indexes (per the YAML config)
+        const key_name = pipe_1.Pipe.resolve(this.config.key_name, this.context);
+        const key_value = pipe_1.Pipe.resolve(this.config.key_value, this.context);
+        const indexQueryFacets = [`${key_name}:${key_value}`];
+        //execute: `hookAll` will now resume all paused jobs that share the same job key
+        return await this.engine.hookAll(this.config.topic, signalInputData, keyResolverData, indexQueryFacets);
+    }
+}
+exports.Signal = Signal;

package/build/services/activities/trigger.js

@@ -44,10 +44,10 @@ class Trigger extends activity_1.Activity {
         }
         catch (error) {
             if (error instanceof errors_1.DuplicateJobError) {
-                this.logger.error('duplicate-job-error', error);
+                this.logger.error('duplicate-job-error', { error });
             }
             else {
-                this.logger.error('trigger-process-error', error);
+                this.logger.error('trigger-process-error', { error });
             }
             telemetry.setActivityError(error.message);
             throw error;
@@ -121,6 +121,7 @@ class Trigger extends activity_1.Activity {
             },
         };
         this.context['$self'] = this.context[this.metadata.aid];
+        this.context['$job'] = this.context; //NEVER call STRINGIFY! (circular)
     }
     bindJobMetadataPaths() {
         return serializer_1.MDATA_SYMBOLS.JOB.KEYS.map((key) => `metadata/${key}`);
@@ -129,7 +130,7 @@ class Trigger extends activity_1.Activity {
         return serializer_1.MDATA_SYMBOLS.ACTIVITY.KEYS.map((key) => `output/metadata/${key}`);
     }
     resolveGranularity() {
-        return reporter_1.ReporterService.DEFAULT_GRANULARITY;
+        return this.config.stats?.granularity || reporter_1.ReporterService.DEFAULT_GRANULARITY;
     }
     getJobStatus() {
         return this.context.metadata.js;

package/build/services/activities/worker.d.ts

@@ -2,10 +2,11 @@ import { Activity } from './activity';
 import { EngineService } from '../engine';
 import { ActivityData, ActivityMetadata, ActivityType, WorkerActivity } from '../../types/activity';
 import { JobState } from '../../types/job';
+import { RedisMulti } from '../../types/redis';
 declare class Worker extends Activity {
     config: WorkerActivity;
     constructor(config: ActivityType, data: ActivityData, metadata: ActivityMetadata, hook: ActivityData | null, engine: EngineService, context?: JobState);
     process(): Promise<string>;
-    execActivity(): Promise<string>;
+    execActivity(multi: RedisMulti): Promise<string>;
 }
 export { Worker };