@hotmeshio/hotmesh 0.0.42 → 0.0.44

package/build/services/router/index.js

@@ -10,6 +10,7 @@ class Router {
     constructor(config, stream, store, logger) {
         this.throttle = 0;
         this.errorCount = 0;
+        this.counts = {};
         this.currentTimerId = null;
         this.appId = config.appId;
         this.guid = config.guid;
@@ -146,6 +147,8 @@ class Router {
             else {
                 output.metadata.guid = (0, utils_1.guid)();
             }
+            const code = output.code || 200;
+            this.counts[code] = (this.counts[code] || 0) + 1;
             output.type = stream_1.StreamDataType.RESPONSE;
             return await this.publishMessage(null, output);
         }

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

@@ -6,6 +6,7 @@ class RedisStoreService extends index_1.StoreService {
     constructor(redisClient) {
         super(redisClient);
         this.commands = {
+            set: 'SET',
             setnx: 'SETNX',
             del: 'DEL',
             expire: 'EXPIRE',

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

@@ -46,10 +46,12 @@ declare abstract class StoreService<T, U extends AbstractRedisClient> {
      * check for and process work items in the
      * time and signal task queues.
      */
-    reserveScoutRole(scoutType: 'time' | 'signal', delay?: number): Promise<boolean>;
+    reserveScoutRole(scoutType: 'time' | 'signal' | 'activate', delay?: number): Promise<boolean>;
+    releaseScoutRole(scoutType: 'time' | 'signal' | 'activate'): Promise<boolean>;
     getSettings(bCreate?: boolean): Promise<HotMeshSettings>;
     setSettings(manifest: HotMeshSettings): Promise<any>;
     reserveSymbolRange(target: string, size: number, type: 'JOB' | 'ACTIVITY'): Promise<[number, number, Symbols]>;
+    getAllSymbols(): Promise<Symbols>;
     getSymbols(activityId: string): Promise<Symbols>;
     addSymbols(activityId: string, symbols: Symbols): Promise<boolean>;
     seedSymbols(target: string, type: 'JOB' | 'ACTIVITY', startIndex: number): StringStringType;
@@ -67,7 +69,7 @@ declare abstract class StoreService<T, U extends AbstractRedisClient> {
      * when `originJobId` is interrupted/expired, the items in the
      * list (added via RPUSH) will be interrupted/expired (removed via LPOPed).
      */
-    registerJobDependency(originJobId: string, topic: string, jobId: string, gId: string, multi?: U): Promise<any>;
+    registerJobDependency(depType: WorkListTaskType, originJobId: string, topic: string, jobId: string, gId: string, multi?: U): Promise<any>;
     /**
      * Ensures a `hook signal` is delisted when its parent activity/job
      * is interrupted/expired.
@@ -86,6 +88,7 @@ declare abstract class StoreService<T, U extends AbstractRedisClient> {
      */
     getQueryState(jobId: string, fields: string[]): Promise<StringAnyType>;
     getState(jobId: string, consumes: Consumes, dIds: StringStringType): Promise<[StringAnyType, number] | undefined>;
+    getRaw(jobId: string): Promise<StringStringType>;
     /**
      * collate is a generic method for incrementing a value in a hash
      * in order to track their progress during processing.
@@ -123,6 +126,7 @@ declare abstract class StoreService<T, U extends AbstractRedisClient> {
      * is a standard `expire` or an `interrupt`
      */
     registerDependenciesForCleanup(jobId: string, deletionTime: number, options: JobCompletionOptions): Promise<void>;
+    getDependencies(jobId: string): Promise<string[]>;
     /**
      * registers a hook activity to be awakened (uses ZSET to
      * store the 'sleep group' and LIST to store the events
@@ -139,7 +143,7 @@ declare abstract class StoreService<T, U extends AbstractRedisClient> {
      * generic LIST (lists typically contain target job ids)
      * @param {string} listKey - for example `::INTERRUPT::job123` or `job123`
      */
-    resolveTaskKeyContext(listKey: string): [('sleep' | 'expire' | 'interrupt' | 'delist'), string];
+    resolveTaskKeyContext(listKey: string): [WorkListTaskType, string];
     /**
      * Interrupts a job and sets sets a job error (410), if 'throw'!=false.
      * This method is called by the engine and not by an activity and is

package/build/services/store/index.js

@@ -33,6 +33,7 @@ const errors_1 = require("../../modules/errors");
 class StoreService {
     constructor(redisClient) {
         this.commands = {
+            set: 'set',
             setnx: 'setnx',
             del: 'del',
             expire: 'expire',
@@ -106,12 +107,13 @@ class StoreService {
      */
     async reserveScoutRole(scoutType, delay = enums_1.HMSH_SCOUT_INTERVAL_SECONDS) {
         const key = this.mintKey(key_1.KeyType.WORK_ITEMS, { appId: this.appId, scoutType });
-        const success = await this.redisClient[this.commands.setnx](key, `${scoutType}:${(0, utils_1.formatISODate)(new Date())}`);
-        if (this.isSuccessful(success)) {
-            await this.redisClient[this.commands.expire](key, delay - 1);
-            return true;
-        }
-        return false;
+        const success = await this.exec('SET', key, `${scoutType}:${(0, utils_1.formatISODate)(new Date())}`, 'NX', 'EX', `${delay - 1}`);
+        return this.isSuccessful(success);
+    }
+    async releaseScoutRole(scoutType) {
+        const key = this.mintKey(key_1.KeyType.WORK_ITEMS, { appId: this.appId, scoutType });
+        const success = await this.exec('DEL', key);
+        return this.isSuccessful(success);
     }
     async getSettings(bCreate = false) {
         let settings = this.cache?.getSettings();
@@ -162,6 +164,35 @@ class StoreService {
             return [actualLowerLimit, upperLimit, symbols];
         }
     }
+    async getAllSymbols() {
+        //get hash with all reserved symbol ranges
+        const rangeKey = this.mintKey(key_1.KeyType.SYMKEYS, { appId: this.appId });
+        const ranges = await this.redisClient[this.commands.hgetall](rangeKey);
+        const rangeKeys = Object.keys(ranges).sort();
+        delete rangeKeys[':cursor'];
+        const multi = this.getMulti();
+        for (const rangeKey of rangeKeys) {
+            const symbolKey = this.mintKey(key_1.KeyType.SYMKEYS, { activityId: rangeKey, appId: this.appId });
+            multi[this.commands.hgetall](symbolKey);
+        }
+        const results = await multi.exec();
+        const symbolSets = {};
+        results.forEach((result, index) => {
+            if (result) {
+                let vals;
+                if (Array.isArray(result) && result.length === 2) {
+                    vals = result[1];
+                }
+                else {
+                    vals = result;
+                }
+                for (const [key, value] of Object.entries(vals)) {
+                    symbolSets[value] = key.startsWith(rangeKeys[index]) ? key : `${rangeKeys[index]}/${key}`;
+                }
+            }
+        });
+        return symbolSets;
+    }
     async getSymbols(activityId) {
         let symbols = this.cache.getSymbols(this.appId, activityId);
         if (symbols) {
@@ -312,15 +343,15 @@ class StoreService {
      * when `originJobId` is interrupted/expired, the items in the
      * list (added via RPUSH) will be interrupted/expired (removed via LPOPed).
      */
-    async registerJobDependency(originJobId, topic, jobId, gId, multi) {
+    async registerJobDependency(depType, originJobId, topic, jobId, gId, multi) {
         const privateMulti = multi || this.getMulti();
         const dependencyParams = {
             appId: this.appId,
             jobId: originJobId,
         };
         const depKey = this.mintKey(key_1.KeyType.JOB_DEPENDENTS, dependencyParams);
-        //tasks have '4' segments
-        const expireTask = `expire::${topic}::${gId}::${jobId}`;
+        //items listed as job dependencies have different relationships
+        const expireTask = `${depType}::${topic}::${gId}::${jobId}`;
         privateMulti[this.commands.rpush](depKey, expireTask);
         if (!multi) {
             return await privateMulti.exec();
@@ -485,6 +516,14 @@ class StoreService {
             throw new errors_1.GetStateError(jobId);
         }
     }
+    async getRaw(jobId) {
+        const jobKey = this.mintKey(key_1.KeyType.JOB_STATE, { appId: this.appId, jobId });
+        const job = await this.redisClient[this.commands.hgetall](jobKey);
+        if (!job) {
+            throw new errors_1.GetStateError(jobId);
+        }
+        return job;
+    }
     /**
      * collate is a generic method for incrementing a value in a hash
      * in order to track their progress during processing.
@@ -718,6 +757,11 @@ class StoreService {
         const zsetKey = this.mintKey(key_1.KeyType.TIME_RANGE, { appId: this.appId });
         await this.zAdd(zsetKey, deletionTime.toString(), depKeyContext);
     }
+    async getDependencies(jobId) {
+        const depParams = { appId: this.appId, jobId };
+        const depKey = this.mintKey(key_1.KeyType.JOB_DEPENDENTS, depParams);
+        return this.redisClient[this.commands.lrange](depKey, 0, -1);
+    }
     /**
      * registers a hook activity to be awakened (uses ZSET to
      * store the 'sleep group' and LIST to store the events
@@ -740,12 +784,18 @@ class StoreService {
             let [pType, pKey] = this.resolveTaskKeyContext(listKey);
             const timeEvent = await this.redisClient[this.commands.lpop](pKey);
             if (timeEvent) {
-                //there are 4 time-related task
-                //1) sleep (awaken), 2) expire, 3) interrupt, 4) delist
-                const [type, activityId, gId, ...jobId] = timeEvent.split('::');
+                //there are task types
+                //1) sleep (awaken), 2) expire (OR expire-child), 3) interrupt, 4) delist, 5) child (just an index helper; no work to do)
+                let [type, activityId, gId, ...jobId] = timeEvent.split('::');
                 if (type === 'delist') {
                     pType = 'delist';
                 }
+                else if (type === 'child') {
+                    pType = 'child';
+                }
+                else if (type === 'expire-child') {
+                    type = 'expire'; //use the same logic as 'expire'
+                }
                 return [listKey, jobId.join('::'), gId, activityId, pType];
             }
             await this.redisClient[this.commands.zrem](zsetKey, listKey);

package/build/services/task/index.js

@@ -75,7 +75,11 @@ class TaskService {
                 const workListTask = await this.store.getNextTask(listKey);
                 if (Array.isArray(workListTask)) {
                     const [listKey, target, gId, activityId, type] = workListTask;
-                    if (type === 'delist') {
+                    if (type === 'child') {
+                        //continue; this child is listed here for convenience, but
+                        //  will be expired by an origin ancestor and is listed there
+                    }
+                    else if (type === 'delist') {
                         //delist the signalKey (target)
                         const key = this.store.mintKey(hotmesh_1.KeyType.SIGNALS, { appId: this.store.appId });
                         await this.store.redisClient[this.store.commands.hdel](key, target);

package/build/services/worker/index.js

@@ -2,16 +2,16 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.WorkerService = void 0;
 const key_1 = require("../../modules/key");
+const utils_1 = require("../../modules/utils");
+const connector_1 = require("../connector");
 const router_1 = require("../router");
-const redis_1 = require("../store/clients/redis");
 const ioredis_1 = require("../store/clients/ioredis");
-const redis_2 = require("../stream/clients/redis");
+const redis_1 = require("../store/clients/redis");
 const ioredis_2 = require("../stream/clients/ioredis");
+const redis_2 = require("../stream/clients/redis");
 const ioredis_3 = require("../sub/clients/ioredis");
 const redis_3 = require("../sub/clients/redis");
 const stream_1 = require("../../types/stream");
-const utils_1 = require("../../modules/utils");
-const connector_1 = require("../connector");
 class WorkerService {
     constructor() {
         this.reporting = false;
@@ -114,6 +114,7 @@ class WorkerService {
                 app_id: this.appId,
                 worker_topic: this.topic,
                 stream: this.stream.mintKey(key_1.KeyType.STREAMS, params),
+                counts: this.router.counts,
             };
         }
         this.store.publish(key_1.KeyType.QUORUM, {

package/build/types/activity.d.ts

@@ -33,13 +33,18 @@ interface Measure {
 }
 interface TriggerActivityStats {
     /**
-     * parent job; including this allows the parent's
+     * dependent parent job id; including this allows the parent's
      * expiration/interruption events to cascade; set
      * `expire` in the YAML for the dependent graph
      * to 0 and provide the parent for dependent,
      * cascading interruption and cleanup
      */
     parent?: string;
+    /**
+     * adjacent parent job id; this is the actual adjacent
+     * parent in the graph, but it is not used for cascading expiration
+     */
+    adjacent?: string;
     id?: {
         [key: string]: unknown;
     } | string;

package/build/types/exporter.d.ts

@@ -0,0 +1,51 @@
+import { StringAnyType } from "./serializer";
+export type ExportItem = [(string | null), string, any];
+export interface ExportOptions {
+}
+export type JobAction = {
+    cursor: number;
+    items: ExportItem[];
+};
+export interface JobActionExport {
+    hooks: {
+        [key: string]: JobAction;
+    };
+    main: JobAction;
+}
+export interface ActivityAction {
+    action: string;
+    target: string;
+}
+export interface JobTimeline {
+    activity: string;
+    dimension: string;
+    duplex: 'entry' | 'exit';
+    timestamp: string;
+    actions?: ActivityAction[];
+}
+export interface DependencyExport {
+    type: string;
+    topic: string;
+    gid: string;
+    jid: string;
+}
+export interface ExportTransitions {
+    [key: string]: string[];
+}
+export interface ExportCycles {
+    [key: string]: string[];
+}
+export interface DurableJobExport {
+    data: StringAnyType;
+    dependencies: DependencyExport[];
+    state: StringAnyType;
+    status: string;
+    timeline: JobTimeline[];
+    transitions: ExportTransitions;
+    cycles: ExportCycles;
+}
+export interface JobExport {
+    dependencies: DependencyExport[];
+    process: StringAnyType;
+    status: string;
+}

package/build/types/exporter.js

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

package/build/types/hotmesh.d.ts

@@ -42,7 +42,7 @@ type KeyStoreParams = {
     facet?: string;
     topic?: string;
     timeValue?: number;
-    scoutType?: 'signal' | 'time';
+    scoutType?: 'signal' | 'time' | 'activate';
 };
 type HotMesh = typeof HotMeshService;
 type RedisConfig = {

package/build/types/index.d.ts

@@ -4,6 +4,7 @@ export { AsyncSignal } from './async';
 export { CacheMode } from './cache';
 export { CollationFaultType, CollationStage } from './collator';
 export { ActivityConfig, ActivityWorkflowDataType, ClientConfig, ContextType, ConnectionConfig, Connection, ProxyType, Registry, SignalOptions, FindOptions, FindWhereOptions, FindWhereQuery, HookOptions, MeshOSActivityOptions, MeshOSWorkerOptions, MeshOSClassConfig, MeshOSConfig, MeshOSOptions, WorkflowConfig, WorkerConfig, WorkerOptions, WorkflowContext, WorkflowSearchOptions, WorkflowDataType, WorkflowOptions, } from './durable';
+export { ActivityAction, DependencyExport, DurableJobExport, ExportCycles, ExportItem, ExportOptions, ExportTransitions, JobAction, JobExport, JobActionExport, JobTimeline } from './exporter';
 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/quorum.d.ts

@@ -6,6 +6,7 @@ export interface QuorumProfile {
     worker_topic?: string;
     stream?: string;
     stream_depth?: number;
+    counts?: Record<string, number>;
 }
 export interface PingMessage {
     type: 'ping';

package/build/types/task.d.ts

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

package/modules/enums.ts

@@ -22,6 +22,10 @@ export const HMSH_CODE_DURABLE_RETRYABLE = 599;
 
 export const HMSH_STATUS_UNKNOWN = 'unknown';
 
+// QUORUM
+export const HMSH_QUORUM_DELAY_MS = 250;
+export const HMSH_ACTIVATION_MAX_RETRY = 3;
+
 // ENGINE
 export const HMSH_OTT_WAIT_TIME = parseInt(process.env.HMSH_OTT_WAIT_TIME, 10) || 1000;
 export const HMSH_EXPIRE_JOB_SECONDS = parseInt(process.env.HMSH_EXPIRE_JOB_SECONDS, 10) || 1;

package/modules/utils.ts

@@ -10,7 +10,7 @@ export async function sleepFor(ms: number) {
 }
 
 export function guid(): string {
-  return nanoid();
+  return nanoid().replace(/[_-]/g, '0');
 }
 
 export function deterministicRandom(seed: number): number {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hotmeshio/hotmesh",
-  "version": "0.0.42",
+  "version": "0.0.44",
   "description": "Unbreakable Workflows",
   "main": "./build/index.js",
   "types": "./build/index.d.ts",

package/services/activities/trigger.ts

@@ -186,11 +186,15 @@ class Trigger extends Activity {
   async registerJobDependency(multi?: RedisMulti): Promise<void> {
     const depKey = this.config.stats?.parent ?? this.context.metadata.pj;
     let resolvedDepKey = depKey ? Pipe.resolve(depKey, this.context) : '';
+    const adjKey = this.config.stats?.adjacent;
+    let resolvedAdjKey = depKey ? Pipe.resolve(adjKey, this.context) : '';
     if (!resolvedDepKey) {
       resolvedDepKey = this.context.metadata.pj;
     }
     if (resolvedDepKey) {
+      const isParentOrigin = (resolvedDepKey === this.context.metadata.pj) || (resolvedDepKey === resolvedAdjKey);
       await this.store.registerJobDependency(
+        isParentOrigin ? 'expire-child' : 'expire',
         resolvedDepKey,
         this.context.metadata.tpc,
         this.context.metadata.jid,
@@ -198,6 +202,16 @@ class Trigger extends Activity {
         multi,
       );
     }
+    if (resolvedAdjKey && resolvedAdjKey !== resolvedDepKey) {
+      await this.store.registerJobDependency(
+        'child',
+        resolvedAdjKey,
+        this.context.metadata.tpc,
+        this.context.metadata.jid,
+        this.context.metadata.gid,
+        multi,
+      );
+    }
   }
 
   async setStats(multi?: RedisMulti): Promise<void> {

package/services/durable/client.ts

@@ -11,13 +11,14 @@ import { JobState } from '../../types/job';
 import { KeyService, KeyType } from '../../modules/key';
 import { Search } from './search';
 import { StreamStatus } from '../../types';
-import { HMSH_LOGLEVEL, HMSH_EXPIRE_JOB_SECONDS } from '../../modules/enums';
+import { HMSH_LOGLEVEL, HMSH_EXPIRE_JOB_SECONDS, HMSH_QUORUM_DELAY_MS } from '../../modules/enums';
+import { sleepFor } from '../../modules/utils';
 
 export class ClientService {
 
   connection: Connection;
-  topics: string[] = [];
   options: WorkflowOptions;
+  static topics: string[] = [];
   static instances = new Map<string, HotMesh | Promise<HotMesh>>();
 
   constructor(config: ClientConfig) {
@@ -29,8 +30,9 @@ export class ClientService {
     const instanceId = 'SINGLETON';
     if (ClientService.instances.has(instanceId)) {
       const hotMeshClient = await ClientService.instances.get(instanceId);
-      if (!this.topics.includes(workflowTopic)) {
-        this.topics.push(workflowTopic);
+      await this.verifyWorkflowActive(hotMeshClient, namespace ?? APP_ID);
+      if (!ClientService.topics.includes(workflowTopic)) {
+        ClientService.topics.push(workflowTopic);
         await this.createStream(hotMeshClient, workflowTopic, namespace);
       }
       return hotMeshClient;
@@ -196,6 +198,19 @@ export class ClientService {
     }
   }
 
+  async verifyWorkflowActive(hotMesh: HotMesh, appId = APP_ID, count = 0): Promise<boolean> {
+    const app = await hotMesh.engine.store.getApp(appId);
+    const appVersion = app?.version as unknown as number;
+    if(isNaN(appVersion)) {
+      if (count > 10) {
+        throw new Error('Workflow failed to activate');
+      }
+      await sleepFor(HMSH_QUORUM_DELAY_MS * 2);
+      return await this.verifyWorkflowActive(hotMesh, appId, count + 1);
+    }
+    return true;
+  }
+
   async activateWorkflow(hotMesh: HotMesh, appId = APP_ID, version = APP_VERSION): Promise<void> {
     const app = await hotMesh.engine.store.getApp(appId);
     const appVersion = app?.version as unknown as number;