@hotmeshio/hotmesh 0.0.33 → 0.0.35

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

@@ -2,7 +2,7 @@ import { Activity } from './activity';
 import { Await } from './await';
 import { Cycle } from './cycle';
 import { Hook } from './hook';
-import { Iterate } from './iterate';
+import { Interrupt } from './interrupt';
 import { Signal } from './signal';
 import { Trigger } from './trigger';
 import { Worker } from './worker';
@@ -11,7 +11,7 @@ declare const _default: {
     await: typeof Await;
     cycle: typeof Cycle;
     hook: typeof Hook;
-    iterate: typeof Iterate;
+    interrupt: typeof Interrupt;
     signal: typeof Signal;
     trigger: typeof Trigger;
     worker: typeof Worker;

package/build/services/activities/index.js

@@ -4,7 +4,7 @@ const activity_1 = require("./activity");
 const await_1 = require("./await");
 const cycle_1 = require("./cycle");
 const hook_1 = require("./hook");
-const iterate_1 = require("./iterate");
+const interrupt_1 = require("./interrupt");
 const signal_1 = require("./signal");
 const trigger_1 = require("./trigger");
 const worker_1 = require("./worker");
@@ -13,7 +13,7 @@ exports.default = {
     await: await_1.Await,
     cycle: cycle_1.Cycle,
     hook: hook_1.Hook,
-    iterate: iterate_1.Iterate,
+    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 { Activity, ActivityType } from './activity';
+import { ActivityData, ActivityMetadata, InterruptActivity } from '../../types/activity';
+import { JobInterruptOptions, JobState } from '../../types/job';
+import { TelemetryService } from '../telemetry';
+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,129 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Interrupt = void 0;
+const activity_1 = require("./activity");
+const errors_1 = require("../../modules/errors");
+const collator_1 = require("../collator");
+const telemetry_1 = require("../telemetry");
+const pipe_1 = require("../pipe");
+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, aid: this.metadata.aid });
+        let telemetry;
+        try {
+            this.setLeg(1);
+            await collator_1.CollatorService.notarizeEntry(this);
+            await this.getState();
+            collator_1.CollatorService.assertJobActive(this.context.metadata.js, this.context.metadata.jid, this.metadata.aid); // Ensure job active
+            telemetry = new telemetry_1.TelemetryService(this.engine.appId, this.config, this.metadata, this.context);
+            telemetry.startActivitySpan(this.leg);
+            if (this.isInterruptingSelf()) {
+                return await this.interruptSelf(telemetry);
+            }
+            else {
+                return 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.GetStateError) {
+                this.logger.error('interrupt-get-state-error', { error });
+                return;
+            }
+            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, 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 multi = this.store.getMulti();
+        await collator_1.CollatorService.notarizeEarlyCompletion(this, multi);
+        await this.setStatus(-1, multi);
+        const multiResponse = await multi.exec();
+        const jobStatus = this.resolveStatus(multiResponse);
+        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 multi = this.store.getMulti();
+            await this.setState(multi);
+        }
+        // Notarize completion
+        const multi = this.store.getMulti();
+        await collator_1.CollatorService.notarizeEarlyCompletion(this, multi);
+        await this.setStatus(this.adjacencyList.length - 1, multi);
+        const multiResponse = await multi.exec();
+        const jobStatus = this.resolveStatus(multiResponse);
+        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,
+        };
+    }
+    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.js

@@ -20,6 +20,7 @@ class Signal extends activity_1.Activity {
             this.setLeg(1);
             await collator_1.CollatorService.notarizeEntry(this);
             await this.getState();
+            collator_1.CollatorService.assertJobActive(this.context.metadata.js, this.context.metadata.jid, this.metadata.aid);
             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)
@@ -31,6 +32,7 @@ class Signal extends activity_1.Activity {
             await collator_1.CollatorService.notarizeEarlyCompletion(this, multi);
             await this.setStatus(this.adjacencyList.length - 1, multi);
             const multiResponse = await multi.exec();
+            //todo: this should execute BEFORE the status is decremented
             if (this.config.subtype === 'all') {
                 await this.hookAll();
             }
@@ -49,8 +51,13 @@ class Signal extends activity_1.Activity {
             return this.context.metadata.aid;
         }
         catch (error) {
-            if (error instanceof errors_1.GetStateError) {
+            if (error instanceof errors_1.InactiveJobError) {
+                this.logger.error('signal-inactive-job-error', { error });
+                return;
+            }
+            else if (error instanceof errors_1.GetStateError) {
                 this.logger.error('signal-get-state-error', { error });
+                return;
             }
             else {
                 this.logger.error('signal-process-error', { error });
@@ -59,7 +66,7 @@ class Signal extends activity_1.Activity {
             throw error;
         }
         finally {
-            telemetry.endActivitySpan();
+            telemetry?.endActivitySpan();
             this.logger.debug('signal-process-end', { jid: this.context.metadata.jid, aid: this.metadata.aid });
         }
     }

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

@@ -17,6 +17,10 @@ declare class Trigger extends Activity {
     resolveJobId(context: Partial<JobState>): string;
     resolveJobKey(context: Partial<JobState>): string;
     setStateNX(): Promise<void>;
+    /**
+     * Registers this job as a dependent of the parent job
+     */
+    setDependency(multi?: RedisMulti): Promise<void>;
     setStats(multi?: RedisMulti): Promise<void>;
 }
 export { Trigger };

package/build/services/activities/trigger.js

@@ -1,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Trigger = void 0;
-const nanoid_1 = require("nanoid");
 const errors_1 = require("../../modules/errors");
 const utils_1 = require("../../modules/utils");
 const activity_1 = require("./activity");
@@ -30,6 +29,7 @@ class Trigger extends activity_1.Activity {
             const multi = this.store.getMulti();
             await this.setState(multi);
             await this.setStats(multi);
+            await this.setDependency(multi);
             await multi.exec();
             telemetry.mapActivityAttributes();
             const jobStatus = Number(this.context.metadata.js);
@@ -53,8 +53,8 @@ class Trigger extends activity_1.Activity {
             throw error;
         }
         finally {
-            telemetry.endJobSpan();
-            telemetry.endActivitySpan();
+            telemetry?.endJobSpan();
+            telemetry?.endActivitySpan();
             this.logger.debug('trigger-process-end', { subscribes: this.config.subscribes, jid: this.context.metadata.jid });
         }
     }
@@ -137,7 +137,7 @@ class Trigger extends activity_1.Activity {
     }
     resolveJobId(context) {
         const jobId = this.config.stats?.id;
-        return jobId ? pipe_1.Pipe.resolve(jobId, context) : (0, nanoid_1.nanoid)();
+        return jobId ? pipe_1.Pipe.resolve(jobId, context) : (0, utils_1.guid)();
     }
     resolveJobKey(context) {
         const jobKey = this.config.stats?.key;
@@ -149,6 +149,16 @@ class Trigger extends activity_1.Activity {
             throw new errors_1.DuplicateJobError(jobId);
         }
     }
+    /**
+     * Registers this job as a dependent of the parent job
+     */
+    async setDependency(multi) {
+        const depKey = this.config.stats?.parent;
+        const resolvedDepKey = depKey ? pipe_1.Pipe.resolve(depKey, this.context) : '';
+        if (resolvedDepKey) {
+            await this.store.setDependency(resolvedDepKey, this.context.metadata.tpc, this.context.metadata.jid, multi);
+        }
+    }
     async setStats(multi) {
         const md = this.context.metadata;
         if (md.key && this.config.stats?.measures) {

package/build/services/activities/worker.js

@@ -6,6 +6,7 @@ const activity_1 = require("./activity");
 const collator_1 = require("../collator");
 const telemetry_1 = require("../telemetry");
 const pipe_1 = require("../pipe");
+const utils_1 = require("../../modules/utils");
 class Worker extends activity_1.Activity {
     constructor(config, data, metadata, hook, engine, context) {
         super(config, data, metadata, hook, engine, context);
@@ -19,6 +20,7 @@ class Worker extends activity_1.Activity {
             this.setLeg(1);
             await collator_1.CollatorService.notarizeEntry(this);
             await this.getState();
+            collator_1.CollatorService.assertJobActive(this.context.metadata.js, this.context.metadata.jid, this.metadata.aid);
             telemetry = new telemetry_1.TelemetryService(this.engine.appId, this.config, this.metadata, this.context);
             telemetry.startActivitySpan(this.leg);
             this.mapInputData();
@@ -40,8 +42,13 @@ class Worker extends activity_1.Activity {
             return this.context.metadata.aid;
         }
         catch (error) {
-            if (error instanceof errors_1.GetStateError) {
+            if (error instanceof errors_1.InactiveJobError) {
+                this.logger.error('await-inactive-job-error', { error });
+                return;
+            }
+            else if (error instanceof errors_1.GetStateError) {
                 this.logger.error('worker-get-state-error', { error });
+                return;
             }
             else {
                 this.logger.error('worker-process-error', { error });
@@ -50,7 +57,7 @@ class Worker extends activity_1.Activity {
             throw error;
         }
         finally {
-            telemetry.endActivitySpan();
+            telemetry?.endActivitySpan();
             this.logger.debug('worker-process-end', { jid: this.context.metadata.jid, aid: this.metadata.aid });
         }
     }
@@ -58,6 +65,7 @@ class Worker extends activity_1.Activity {
         const topic = pipe_1.Pipe.resolve(this.config.subtype, this.context);
         const streamData = {
             metadata: {
+                guid: (0, utils_1.guid)(),
                 jid: this.context.metadata.jid,
                 dad: this.metadata.dad,
                 aid: this.metadata.aid,

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

@@ -6,6 +6,10 @@ import { Activity } from '../activities/activity';
 import { Cycle } from '../activities/cycle';
 declare class CollatorService {
     static targetLength: number;
+    /**
+     * Upon re/entry, verify that the job status is active
+     */
+    static assertJobActive(status: number, jobId: string, activityId: string): void;
     /**
      * returns the dimensional address (dad) for the target; due
      * to the nature of the notary system, the dad for leg 2 entry

package/build/services/collator/index.js

@@ -4,6 +4,14 @@ exports.CollatorService = void 0;
 const errors_1 = require("../../modules/errors");
 const collator_1 = require("../../types/collator");
 class CollatorService {
+    /**
+     * Upon re/entry, verify that the job status is active
+     */
+    static assertJobActive(status, jobId, activityId) {
+        if (status <= 0) {
+            throw new errors_1.InactiveJobError(jobId, status, activityId);
+        }
+    }
     /**
      * returns the dimensional address (dad) for the target; due
      * to the nature of the notary system, the dad for leg 2 entry

package/build/services/compiler/deployer.js

@@ -132,9 +132,7 @@ class Deployer {
                 if (graph.publishes) {
                     activities[activityKey].publishes = graph.publishes;
                 }
-                if (graph.expire) {
-                    activities[activityKey].expire = graph.expire;
-                }
+                activities[activityKey].expire = graph.expire ?? undefined;
             }
         }
     }

package/build/services/connector/index.js

@@ -1,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ConnectorService = void 0;
-const nanoid_1 = require("nanoid");
 const utils_1 = require("../../modules/utils");
 const ioredis_1 = require("../connector/clients/ioredis");
 const redis_1 = require("../connector/clients/redis");
@@ -13,12 +12,12 @@ class ConnectorService {
             const instances = [];
             if ((0, utils_1.identifyRedisTypeFromClass)(Redis) === 'redis') {
                 for (let i = 1; i <= 3; i++) {
-                    instances.push(redis_1.RedisConnection.connect((0, nanoid_1.nanoid)(), Redis, options));
+                    instances.push(redis_1.RedisConnection.connect((0, utils_1.guid)(), Redis, options));
                 }
             }
             else {
                 for (let i = 1; i <= 3; i++) {
-                    instances.push(ioredis_1.RedisConnection.connect((0, nanoid_1.nanoid)(), Redis, options));
+                    instances.push(ioredis_1.RedisConnection.connect((0, utils_1.guid)(), Redis, options));
                 }
             }
             const [store, stream, sub] = await Promise.all(instances);

package/build/services/durable/client.js

@@ -7,6 +7,7 @@ const hotmesh_1 = require("../hotmesh");
 const key_1 = require("../../modules/key");
 const search_1 = require("./search");
 const types_1 = require("../../types");
+const enums_1 = require("../../modules/enums");
 class ClientService {
     constructor(config) {
         this.getHotMeshClient = async (worflowTopic, namespace) => {
@@ -80,12 +81,15 @@ class ClientService {
                 const workflowName = options.entity ?? options.workflowName;
                 const trc = options.workflowTrace;
                 const spn = options.workflowSpan;
-                //topic is concat of taskQueue and workflowName
+                //NOTE: HotMesh 'workflowTopic' is a created by concatenating
+                //     the taskQueue and workflowName used by the Durable module
                 const workflowTopic = `${taskQueueName}-${workflowName}`;
                 const hotMeshClient = await this.getHotMeshClient(workflowTopic, options.namespace);
                 this.configureSearchIndex(hotMeshClient, options.search);
                 const payload = {
                     arguments: [...options.args],
+                    originJobId: options.originJobId,
+                    expire: options.expire ?? enums_1.DURABLE_EXPIRE_SECONDS,
                     parentWorkflowId: options.parentWorkflowId,
                     workflowId: options.workflowId || hotmesh_1.HotMeshService.guid(),
                     workflowTopic: workflowTopic,
@@ -93,12 +97,12 @@ class ClientService {
                 };
                 const context = { metadata: { trc, spn }, data: {} };
                 const jobId = await hotMeshClient.pub(`${options.namespace ?? factory_1.APP_ID}.execute`, payload, context);
-                // Seed search data if present
+                // Seed search data
                 if (jobId && options.search?.data) {
                     const searchSessionId = `-search-0`;
                     const search = new search_1.Search(jobId, hotMeshClient, searchSessionId);
                     const entries = Object.entries(options.search.data).flat();
-                    search.set(...entries);
+                    await search.set(...entries);
                 }
                 return new handle_1.WorkflowHandleService(hotMeshClient, workflowTopic, jobId);
             },
@@ -178,9 +182,8 @@ class ClientService {
         }
     }
     static async shutdown() {
-        for (const [key, value] of ClientService.instances) {
-            const hotMesh = await value;
-            await hotMesh.stop();
+        for (const [_, hotMeshInstance] of ClientService.instances) {
+            (await hotMeshInstance).stop();
         }
     }
 }