@hotmeshio/hotmesh 0.4.0 → 0.4.1

package/build/services/activities/await.js

@@ -0,0 +1,114 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Await = void 0;
+const errors_1 = require("../../modules/errors");
+const utils_1 = require("../../modules/utils");
+const collator_1 = require("../collator");
+const pipe_1 = require("../pipe");
+const telemetry_1 = require("../telemetry");
+const stream_1 = require("../../types/stream");
+const activity_1 = require("./activity");
+class Await extends activity_1.Activity {
+    constructor(config, data, metadata, hook, engine, context) {
+        super(config, data, metadata, hook, engine, context);
+    }
+    //********  INITIAL ENTRY POINT (A)  ********//
+    async process() {
+        this.logger.debug('await-process', {
+            jid: this.context.metadata.jid,
+            gid: this.context.metadata.gid,
+            aid: this.metadata.aid,
+        });
+        let telemetry;
+        try {
+            await this.verifyEntry();
+            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 transaction = this.store.transact();
+            //todo: await this.registerTimeout();
+            const messageId = await this.execActivity(transaction);
+            await collator_1.CollatorService.authorizeReentry(this, transaction);
+            await this.setState(transaction);
+            await this.setStatus(0, transaction);
+            const multiResponse = (await transaction.exec());
+            //telemetry
+            telemetry.mapActivityAttributes();
+            const jobStatus = this.resolveStatus(multiResponse);
+            telemetry.setActivityAttributes({
+                'app.activity.mid': messageId,
+                'app.job.jss': jobStatus,
+            });
+            return this.context.metadata.aid;
+        }
+        catch (error) {
+            if (error instanceof errors_1.InactiveJobError) {
+                this.logger.error('await-inactive-job-error', { error });
+                return;
+            }
+            else if (error instanceof errors_1.GenerationalError) {
+                this.logger.info('process-event-generational-job-error', { error });
+                return;
+            }
+            else if (error instanceof errors_1.GetStateError) {
+                this.logger.error('await-get-state-error', { error });
+                return;
+            }
+            else if (error instanceof errors_1.CollationError) {
+                if (error.fault === 'duplicate') {
+                    this.logger.info('await-collation-overage', {
+                        job_id: this.context.metadata.jid,
+                        guid: this.context.metadata.guid,
+                    });
+                    return;
+                }
+                //unknown collation error
+                this.logger.error('await-collation-error', { error });
+            }
+            else {
+                this.logger.error('await-process-error', { error });
+            }
+            telemetry?.setActivityError(error.message);
+            throw error;
+        }
+        finally {
+            telemetry?.endActivitySpan();
+            this.logger.debug('await-process-end', {
+                jid: this.context.metadata.jid,
+                gid: this.context.metadata.gid,
+                aid: this.metadata.aid,
+            });
+        }
+    }
+    async execActivity(transaction) {
+        const topic = pipe_1.Pipe.resolve(this.config.subtype, this.context);
+        const streamData = {
+            metadata: {
+                guid: (0, utils_1.guid)(),
+                jid: this.context.metadata.jid,
+                gid: this.context.metadata.gid,
+                dad: this.metadata.dad,
+                aid: this.metadata.aid,
+                topic,
+                spn: this.context['$self'].output.metadata?.l1s,
+                trc: this.context.metadata.trc,
+            },
+            type: stream_1.StreamDataType.AWAIT,
+            data: this.context.data,
+        };
+        if (this.config.await !== true) {
+            const doAwait = pipe_1.Pipe.resolve(this.config.await, this.context);
+            if (doAwait === false) {
+                streamData.metadata.await = false;
+            }
+        }
+        if (this.config.retry) {
+            streamData.policies = {
+                retry: this.config.retry,
+            };
+        }
+        return (await this.engine.router?.publishMessage(null, streamData, transaction));
+    }
+}
+exports.Await = Await;

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

@@ -0,0 +1,19 @@
+import { EngineService } from '../engine';
+import { ActivityData, ActivityMetadata, ActivityType, CycleActivity } from '../../types/activity';
+import { ProviderTransaction } from '../../types/provider';
+import { JobState } from '../../types/job';
+import { Activity } from './activity';
+declare class Cycle extends Activity {
+    config: CycleActivity;
+    constructor(config: ActivityType, data: ActivityData, metadata: ActivityMetadata, hook: ActivityData | null, engine: EngineService, context?: JobState);
+    process(): Promise<string>;
+    /**
+     * Trigger the target ancestor to execute in a cycle,
+     * without violating the constraints of the DAG. Immutable
+     * `individual activity state` will execute in a new dimensional
+     * thread while `shared job state` can change. This
+     * pattern allows for retries without violating the DAG.
+     */
+    cycleAncestorActivity(transaction: ProviderTransaction): Promise<string>;
+}
+export { Cycle };

package/build/services/activities/cycle.js

@@ -0,0 +1,112 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Cycle = void 0;
+const errors_1 = require("../../modules/errors");
+const utils_1 = require("../../modules/utils");
+const collator_1 = require("../collator");
+const telemetry_1 = require("../telemetry");
+const activity_1 = require("./activity");
+class Cycle 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('cycle-process', {
+            jid: this.context.metadata.jid,
+            gid: this.context.metadata.gid,
+            aid: this.metadata.aid,
+        });
+        let telemetry;
+        try {
+            await this.verifyEntry();
+            telemetry = new telemetry_1.TelemetryService(this.engine.appId, this.config, this.metadata, this.context);
+            telemetry.startActivitySpan(this.leg);
+            this.mapInputData();
+            //set state/status
+            let transaction = this.store.transact();
+            await this.setState(transaction);
+            await this.setStatus(0, transaction); //leg 1 never changes job status
+            const txResponse = (await transaction.exec());
+            telemetry.mapActivityAttributes();
+            const jobStatus = this.resolveStatus(txResponse);
+            //cycle the target ancestor
+            transaction = this.store.transact();
+            const messageId = await this.cycleAncestorActivity(transaction);
+            telemetry.setActivityAttributes({
+                'app.activity.mid': messageId,
+                'app.job.jss': jobStatus,
+            });
+            //exit early (`Cycle` activities only execute Leg 1)
+            await collator_1.CollatorService.notarizeEarlyExit(this, transaction);
+            (await transaction.exec());
+            return this.context.metadata.aid;
+        }
+        catch (error) {
+            if (error instanceof errors_1.InactiveJobError) {
+                this.logger.error('cycle-inactive-job-error', { error });
+                return;
+            }
+            else if (error instanceof errors_1.GenerationalError) {
+                this.logger.info('process-event-generational-job-error', { error });
+                return;
+            }
+            else if (error instanceof errors_1.GetStateError) {
+                this.logger.error('cycle-get-state-error', { error });
+                return;
+            }
+            else if (error instanceof errors_1.CollationError) {
+                if (error.fault === 'duplicate') {
+                    this.logger.info('cycle-collation-overage', {
+                        job_id: this.context.metadata.jid,
+                        guid: this.context.metadata.guid,
+                    });
+                    return;
+                }
+                //unknown collation error
+                this.logger.error('cycle-collation-error', { error });
+            }
+            else {
+                this.logger.error('cycle-process-error', { error });
+            }
+            telemetry?.setActivityError(error.message);
+            throw error;
+        }
+        finally {
+            telemetry?.endActivitySpan();
+            this.logger.debug('cycle-process-end', {
+                jid: this.context.metadata.jid,
+                gid: this.context.metadata.gid,
+                aid: this.metadata.aid,
+            });
+        }
+    }
+    /**
+     * Trigger the target ancestor to execute in a cycle,
+     * without violating the constraints of the DAG. Immutable
+     * `individual activity state` will execute in a new dimensional
+     * thread while `shared job state` can change. This
+     * pattern allows for retries without violating the DAG.
+     */
+    async cycleAncestorActivity(transaction) {
+        //Cycle activity L1 is a standin for the target ancestor L1.
+        //Input data mapping (mapInputData) allows for the
+        //next dimensonal thread to execute with different
+        //input data than the current dimensional thread
+        this.mapInputData();
+        const streamData = {
+            metadata: {
+                guid: (0, utils_1.guid)(),
+                jid: this.context.metadata.jid,
+                gid: this.context.metadata.gid,
+                dad: collator_1.CollatorService.resolveReentryDimension(this),
+                aid: this.config.ancestor,
+                spn: this.context['$self'].output.metadata?.l1s,
+                trc: this.context.metadata.trc,
+            },
+            data: this.context.data,
+        };
+        return (await this.engine.router?.publishMessage(null, streamData, transaction));
+    }
+}
+exports.Cycle = Cycle;

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

@@ -0,0 +1,27 @@
+import { EngineService } from '../engine';
+import { TelemetryService } from '../telemetry';
+import { ActivityData, ActivityMetadata, ActivityType, HookActivity } from '../../types/activity';
+import { HookRule } from '../../types/hook';
+import { JobState, JobStatus } from '../../types/job';
+import { ProviderTransaction } from '../../types/provider';
+import { StreamCode, StreamStatus } from '../../types/stream';
+import { Activity } from './activity';
+/**
+ * Supports `signal hook`, `time hook`, and `cycle hook` patterns
+ */
+declare class Hook extends Activity {
+    config: HookActivity;
+    constructor(config: ActivityType, data: ActivityData, metadata: ActivityMetadata, hook: ActivityData | null, engine: EngineService, context?: JobState);
+    process(): Promise<string>;
+    /**
+     * does this activity use a time-hook or web-hook
+     */
+    doesHook(): boolean;
+    doHook(telemetry: TelemetryService): Promise<void>;
+    doPassThrough(telemetry: TelemetryService): Promise<void>;
+    getHookRule(topic: string): Promise<HookRule | undefined>;
+    registerHook(transaction?: ProviderTransaction): Promise<string | void>;
+    processWebHookEvent(status?: StreamStatus, code?: StreamCode): Promise<JobStatus | void>;
+    processTimeHookEvent(jobId: string): Promise<JobStatus | void>;
+}
+export { Hook };

package/build/services/activities/hook.js

@@ -0,0 +1,168 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Hook = void 0;
+const enums_1 = require("../../modules/enums");
+const errors_1 = require("../../modules/errors");
+const collator_1 = require("../collator");
+const pipe_1 = require("../pipe");
+const task_1 = require("../task");
+const telemetry_1 = require("../telemetry");
+const stream_1 = require("../../types/stream");
+const activity_1 = require("./activity");
+/**
+ * Supports `signal hook`, `time hook`, and `cycle hook` patterns
+ */
+class Hook extends activity_1.Activity {
+    constructor(config, data, metadata, hook, engine, context) {
+        super(config, data, metadata, hook, engine, context);
+    }
+    //********  INITIAL ENTRY POINT (A)  ********//
+    async process() {
+        this.logger.debug('hook-process', {
+            jid: this.context.metadata.jid,
+            gid: this.context.metadata.gid,
+            aid: this.metadata.aid,
+        });
+        let telemetry;
+        try {
+            await this.verifyEntry();
+            telemetry = new telemetry_1.TelemetryService(this.engine.appId, this.config, this.metadata, this.context);
+            telemetry.startActivitySpan(this.leg);
+            if (this.doesHook()) {
+                //sleep and wait to awaken upon a signal
+                await this.doHook(telemetry);
+            }
+            else {
+                //end the activity and transition to its children
+                await this.doPassThrough(telemetry);
+            }
+            return this.context.metadata.aid;
+        }
+        catch (error) {
+            if (error instanceof errors_1.InactiveJobError) {
+                this.logger.error('hook-inactive-job-error', { error });
+                return;
+            }
+            else if (error instanceof errors_1.GenerationalError) {
+                this.logger.info('process-event-generational-job-error', { error });
+                return;
+            }
+            else if (error instanceof errors_1.GetStateError) {
+                this.logger.error('hook-get-state-error', { error });
+                return;
+            }
+            else if (error instanceof errors_1.CollationError) {
+                if (error.fault === 'duplicate') {
+                    this.logger.info('hook-collation-overage', {
+                        job_id: this.context.metadata.jid,
+                        guid: this.context.metadata.guid,
+                    });
+                    return;
+                }
+                //unknown collation error
+                this.logger.error('hook-collation-error', { error });
+            }
+            else {
+                this.logger.error('hook-process-error', { error });
+            }
+            telemetry?.setActivityError(error.message);
+            throw error;
+        }
+        finally {
+            telemetry?.endActivitySpan();
+            this.logger.debug('hook-process-end', {
+                jid: this.context.metadata.jid,
+                gid: this.context.metadata.gid,
+                aid: this.metadata.aid,
+            });
+        }
+    }
+    /**
+     * does this activity use a time-hook or web-hook
+     */
+    doesHook() {
+        if (this.config.sleep) {
+            const duration = pipe_1.Pipe.resolve(this.config.sleep, this.context);
+            return !isNaN(duration) && Number(duration) > 0;
+        }
+        return !!this.config.hook?.topic;
+    }
+    async doHook(telemetry) {
+        const transaction = this.store.transact();
+        //call registerHook separately if in cluster mode
+        //(ok to run this command multiple times if it fails),
+        //but the commands that follow must exec as a transaction
+        await this.registerHook(enums_1.HMSH_IS_CLUSTER ? undefined : transaction);
+        this.mapOutputData();
+        this.mapJobData();
+        await this.setState(transaction);
+        await collator_1.CollatorService.authorizeReentry(this, transaction);
+        await this.setStatus(0, transaction);
+        await transaction.exec();
+        telemetry.mapActivityAttributes();
+    }
+    async doPassThrough(telemetry) {
+        const transaction = this.store.transact();
+        let multiResponse;
+        this.adjacencyList = await this.filterAdjacent();
+        this.mapOutputData();
+        this.mapJobData();
+        await this.setState(transaction);
+        await collator_1.CollatorService.notarizeEarlyCompletion(this, transaction);
+        await this.setStatus(this.adjacencyList.length - 1, transaction);
+        multiResponse = (await transaction.exec());
+        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);
+    }
+    async getHookRule(topic) {
+        const rules = await this.store.getHookRules();
+        return rules?.[topic]?.[0];
+    }
+    async registerHook(transaction) {
+        if (this.config.hook?.topic) {
+            return await this.engine.taskService.registerWebHook(this.config.hook.topic, this.context, this.resolveDad(), this.context.metadata.expire, transaction);
+        }
+        else if (this.config.sleep) {
+            const duration = pipe_1.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, this.metadata.dad || '');
+            return this.context.metadata.jid;
+        }
+    }
+    //********  SIGNAL RE-ENTRY POINT  ********//
+    async processWebHookEvent(status = stream_1.StreamStatus.SUCCESS, code = 200) {
+        this.logger.debug('hook-process-web-hook-event', {
+            topic: this.config.hook.topic,
+            aid: this.metadata.aid,
+            status,
+            code,
+        });
+        const taskService = new task_1.TaskService(this.store, this.logger);
+        const data = { ...this.data };
+        const signal = await taskService.processWebHookSignal(this.config.hook.topic, data);
+        if (signal) {
+            const [jobId, _aid, dad, gId] = signal;
+            this.context.metadata.jid = jobId;
+            this.context.metadata.gid = gId;
+            this.context.metadata.dad = dad;
+            await this.processEvent(status, code, 'hook');
+            if (code === 200) {
+                await taskService.deleteWebHookSignal(this.config.hook.topic, data);
+            } //else => 202/keep alive
+        } //else => already resolved
+    }
+    async processTimeHookEvent(jobId) {
+        this.logger.debug('hook-process-time-hook-event', {
+            jid: jobId,
+            gid: this.context.metadata.gid,
+            aid: this.metadata.aid,
+        });
+        await this.processEvent(stream_1.StreamStatus.SUCCESS, 200, 'hook');
+    }
+}
+exports.Hook = Hook;

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

@@ -0,0 +1,19 @@
+import { Activity } from './activity';
+import { Await } from './await';
+import { Cycle } from './cycle';
+import { Hook } from './hook';
+import { Interrupt } from './interrupt';
+import { Signal } from './signal';
+import { Trigger } from './trigger';
+import { Worker } from './worker';
+declare const _default: {
+    activity: typeof Activity;
+    await: typeof Await;
+    cycle: typeof Cycle;
+    hook: typeof Hook;
+    interrupt: typeof Interrupt;
+    signal: typeof Signal;
+    trigger: typeof Trigger;
+    worker: typeof Worker;
+};
+export default _default;

package/build/services/activities/index.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const activity_1 = require("./activity");
+const await_1 = require("./await");
+const cycle_1 = require("./cycle");
+const hook_1 = require("./hook");
+const interrupt_1 = require("./interrupt");
+const signal_1 = require("./signal");
+const trigger_1 = require("./trigger");
+const worker_1 = require("./worker");
+exports.default = {
+    activity: activity_1.Activity,
+    await: await_1.Await,
+    cycle: cycle_1.Cycle,
+    hook: hook_1.Hook,
+    interrupt: interrupt_1.Interrupt,
+    signal: signal_1.Signal,
+    trigger: trigger_1.Trigger,
+    worker: worker_1.Worker,
+};

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

@@ -0,0 +1,16 @@
+import { EngineService } from '../engine';
+import { TelemetryService } from '../telemetry';
+import { ActivityData, ActivityMetadata, ActivityType, InterruptActivity } from '../../types/activity';
+import { JobInterruptOptions, JobState } from '../../types/job';
+import { Activity } from './activity';
+declare class Interrupt extends Activity {
+    config: InterruptActivity;
+    constructor(config: ActivityType, data: ActivityData, metadata: ActivityMetadata, hook: ActivityData | null, engine: EngineService, context?: JobState);
+    process(): Promise<string>;
+    interruptSelf(telemetry: TelemetryService): Promise<string>;
+    interruptAnother(telemetry: TelemetryService): Promise<string>;
+    isInterruptingSelf(): boolean;
+    resolveInterruptOptions(): JobInterruptOptions;
+    interrupt(): Promise<string>;
+}
+export { Interrupt };

package/build/services/activities/interrupt.js

@@ -0,0 +1,158 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Interrupt = void 0;
+const errors_1 = require("../../modules/errors");
+const collator_1 = require("../collator");
+const pipe_1 = require("../pipe");
+const telemetry_1 = require("../telemetry");
+const activity_1 = require("./activity");
+class Interrupt 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('interrupt-process', {
+            jid: this.context.metadata.jid,
+            gid: this.context.metadata.gid,
+            aid: this.metadata.aid,
+        });
+        let telemetry;
+        try {
+            await this.verifyEntry();
+            telemetry = new telemetry_1.TelemetryService(this.engine.appId, this.config, this.metadata, this.context);
+            telemetry.startActivitySpan(this.leg);
+            if (this.isInterruptingSelf()) {
+                await this.interruptSelf(telemetry);
+            }
+            else {
+                await this.interruptAnother(telemetry);
+            }
+        }
+        catch (error) {
+            if (error instanceof errors_1.InactiveJobError) {
+                this.logger.error('interrupt-inactive-job-error', { error });
+                return;
+            }
+            else if (error instanceof errors_1.GenerationalError) {
+                this.logger.info('process-event-generational-job-error', { error });
+                return;
+            }
+            else if (error instanceof errors_1.GetStateError) {
+                this.logger.error('interrupt-get-state-error', { error });
+                return;
+            }
+            else if (error instanceof errors_1.CollationError) {
+                if (error.fault === 'duplicate') {
+                    this.logger.info('interrupt-collation-overage', {
+                        job_id: this.context.metadata.jid,
+                        guid: this.context.metadata.guid,
+                    });
+                    return;
+                }
+                //unknown collation error
+                this.logger.error('interrupt-collation-error', { error });
+            }
+            else {
+                this.logger.error('interrupt-process-error', { error });
+            }
+            telemetry?.setActivityError(error.message);
+            throw error;
+        }
+        finally {
+            telemetry?.endActivitySpan();
+            this.logger.debug('interrupt-process-end', {
+                jid: this.context.metadata.jid,
+                gid: this.context.metadata.gid,
+                aid: this.metadata.aid,
+            });
+        }
+    }
+    async interruptSelf(telemetry) {
+        // Apply final updates to THIS job's state
+        if (this.config.job?.maps) {
+            this.mapJobData();
+            await this.setState();
+        }
+        // Interrupt THIS job
+        const messageId = await this.interrupt();
+        // Notarize completion and log
+        telemetry.mapActivityAttributes();
+        const transaction = this.store.transact();
+        await collator_1.CollatorService.notarizeEarlyCompletion(this, transaction);
+        await this.setStatus(-1, transaction);
+        const txResponse = (await transaction.exec());
+        const jobStatus = this.resolveStatus(txResponse);
+        telemetry.setActivityAttributes({
+            'app.activity.mid': messageId,
+            'app.job.jss': jobStatus,
+        });
+        return this.context.metadata.aid;
+    }
+    async interruptAnother(telemetry) {
+        // Interrupt ANOTHER job
+        const messageId = await this.interrupt();
+        const attrs = { 'app.activity.mid': messageId };
+        // Apply updates to THIS job's state
+        telemetry.mapActivityAttributes();
+        this.adjacencyList = await this.filterAdjacent();
+        if (this.config.job?.maps || this.config.output?.maps) {
+            this.mapOutputData();
+            this.mapJobData();
+            const transaction = this.store.transact();
+            await this.setState(transaction);
+        }
+        // Notarize completion
+        const transaction = this.store.transact();
+        await collator_1.CollatorService.notarizeEarlyCompletion(this, transaction);
+        await this.setStatus(this.adjacencyList.length - 1, transaction);
+        const txResponse = (await transaction.exec());
+        const jobStatus = this.resolveStatus(txResponse);
+        attrs['app.job.jss'] = jobStatus;
+        // Transition next generation and log
+        const messageIds = await this.transition(this.adjacencyList, jobStatus);
+        if (messageIds.length) {
+            attrs['app.activity.mids'] = messageIds.join(',');
+        }
+        telemetry.setActivityAttributes(attrs);
+        return this.context.metadata.aid;
+    }
+    isInterruptingSelf() {
+        if (!this.config.target) {
+            return true;
+        }
+        const resolvedJob = pipe_1.Pipe.resolve(this.config.target, this.context);
+        return resolvedJob == this.context.metadata.jid;
+    }
+    resolveInterruptOptions() {
+        return {
+            reason: this.config.reason !== undefined
+                ? pipe_1.Pipe.resolve(this.config.reason, this.context)
+                : undefined,
+            throw: this.config.throw !== undefined
+                ? pipe_1.Pipe.resolve(this.config.throw, this.context)
+                : undefined,
+            descend: this.config.descend !== undefined
+                ? pipe_1.Pipe.resolve(this.config.descend, this.context)
+                : undefined,
+            code: this.config.code !== undefined
+                ? pipe_1.Pipe.resolve(this.config.code, this.context)
+                : undefined,
+            expire: this.config.expire !== undefined
+                ? pipe_1.Pipe.resolve(this.config.expire, this.context)
+                : undefined,
+            stack: this.config.stack !== undefined
+                ? pipe_1.Pipe.resolve(this.config.stack, this.context)
+                : undefined,
+        };
+    }
+    async interrupt() {
+        const options = this.resolveInterruptOptions();
+        return await this.engine.interrupt(this.config.topic !== undefined
+            ? pipe_1.Pipe.resolve(this.config.topic, this.context)
+            : this.context.metadata.tpc, this.config.target !== undefined
+            ? pipe_1.Pipe.resolve(this.config.target, this.context)
+            : this.context.metadata.jid, options);
+    }
+}
+exports.Interrupt = Interrupt;

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

@@ -0,0 +1,20 @@
+import { EngineService } from '../engine';
+import { ActivityData, ActivityMetadata, ActivityType, SignalActivity } from '../../types/activity';
+import { JobState } from '../../types/job';
+import { Activity } from './activity';
+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 one
+     */
+    hookOne(): Promise<string>;
+    /**
+     * The signal activity will hook all paused jobs that share the same job key.
+     */
+    hookAll(): Promise<string[]>;
+}
+export { Signal };