@hotmeshio/hotmesh 0.0.36 → 0.0.38

package/services/store/index.ts

@@ -29,7 +29,7 @@ import { Transitions } from '../../types/transition';
 import { formatISODate, getSymKey } from '../../modules/utils';
 import { ReclaimedMessageType } from '../../types/stream';
 import { JobCompletionOptions, JobInterruptOptions } from '../../types/job';
-import { STATUS_CODE_INTERRUPT } from '../../modules/enums';
+import { SCOUT_INTERVAL_SECONDS, STATUS_CODE_INTERRUPT } from '../../modules/enums';
 import { GetStateError } from '../../modules/errors';
 
 interface AbstractRedisClient {
@@ -118,6 +118,10 @@ abstract class StoreService<T, U extends AbstractRedisClient> {
     id: string,
     multi?: U
   ): Promise<number|U>;
+  abstract xlen(
+    key: string,
+    multi?: U
+  ): Promise<number|U>;
 
   constructor(redisClient: T) {
     this.redisClient = redisClient;
@@ -168,10 +172,19 @@ abstract class StoreService<T, U extends AbstractRedisClient> {
     this.cache.invalidate();
   }
 
-  async reserveEngineId(engineId: string): Promise<boolean> {
-    const key = this.mintKey(KeyType.ENGINE_ID, { engineId });
-    const success = await this.redisClient[this.commands.setnx](key, 'id', 1);
-    return this.isSuccessful(success);
+  /**
+   * At any given time only a single engine will
+   * check for and process work items in the
+   * time and signal task queues.
+   */
+  async reserveScoutRole(scoutType: 'time' | 'signal', delay = SCOUT_INTERVAL_SECONDS): Promise<boolean> {
+    const key = this.mintKey(KeyType.WORK_ITEMS, { appId: this.appId, scoutType });
+    const success = await this.redisClient[this.commands.setnx](key, `${scoutType}:${formatISODate(new Date())}`);
+    if (this.isSuccessful(success)) {
+      await this.redisClient[this.commands.expire](key, delay - 1);
+      return true;
+    }
+    return false;
   }
 
   async getSettings(bCreate = false): Promise<HotMeshSettings> {
@@ -380,11 +393,11 @@ abstract class StoreService<T, U extends AbstractRedisClient> {
    * list (added via RPUSH) are LPOPed. If origin was expired, then
    * LPOPed items from the list are likewise expired;
    */
-  async setDependency(originJobId: string, topic: string, jobId: string, multi? : U): Promise<any> {
+  async setDependency(originJobId: string, topic: string, jobId: string, gId: string, multi? : U): Promise<any> {
     const privateMulti = multi || this.getMulti();
     const depParams = { appId: this.appId, jobId: originJobId };
     const depKey = this.mintKey(KeyType.JOB_DEPENDENTS, depParams);
-    privateMulti[this.commands.rpush](depKey, `expire::${topic}::${jobId}`);
+    privateMulti[this.commands.rpush](depKey, `expire::${topic}::${gId}::${jobId}`);
     if (!multi) {
       return await privateMulti.exec();
     }
@@ -784,9 +797,9 @@ abstract class StoreService<T, U extends AbstractRedisClient> {
    * for the given sleep group. Sleep groups are
    * organized into 'n'-second blocks (LISTS))
    */
-  async registerTimeHook(jobId: string, activityId: string, type: 'sleep'|'expire'|'interrupt', deletionTime: number, multi?: U): Promise<void> {
+  async registerTimeHook(jobId: string, gId: string, activityId: string, type: 'sleep'|'expire'|'interrupt', deletionTime: number, multi?: U): Promise<void> {
     const listKey = this.mintKey(KeyType.TIME_RANGE, { appId: this.appId, timeValue: deletionTime });
-    const timeEvent = `${type}::${activityId}::${jobId}`
+    const timeEvent = `${type}::${activityId}::${gId}::${jobId}`;
     const len = await (multi || this.redisClient)[this.commands.rpush](listKey, timeEvent);
     if (multi || len === 1) {
       const zsetKey = this.mintKey(KeyType.TIME_RANGE, { appId: this.appId });
@@ -794,7 +807,8 @@ abstract class StoreService<T, U extends AbstractRedisClient> {
     }
   }
 
-  async getNextTimeJob(listKey?: string): Promise<[listKey: string, jobId: string, activityId: string, type: 'sleep'|'expire'|'interrupt'] | void> {
+  async getNextTimeJob(listKey?: string): Promise<[listKey: string, jobId: string, gId: string, activityId: string, type: 'sleep'|'expire'|'interrupt'] | boolean> {
+    const existing = Boolean(listKey);
     const zsetKey = this.mintKey(KeyType.TIME_RANGE, { appId: this.appId });
     listKey = listKey || await this.zRangeByScore(zsetKey, 0, Date.now());
     if (listKey) {
@@ -802,11 +816,12 @@ abstract class StoreService<T, U extends AbstractRedisClient> {
       const timeEvent = await this.redisClient[this.commands.lpop](pKey);
       if (timeEvent) {
         //there are 3 time-related event triggers: sleep, expire, interrupt
-        const [_type, activityId, ...jobId] = timeEvent.split('::');
-        return [listKey, jobId.join('::'), activityId, pType];
+        const [_type, activityId, gId, ...jobId] = timeEvent.split('::');
+        return [listKey, jobId.join('::'), gId, activityId, pType];
       }
       await this.redisClient[this.commands.zrem](zsetKey, listKey);
     }
+    return existing;
   }
 
   /**

package/services/stream/clients/ioredis.ts

@@ -33,16 +33,16 @@ class IORedisStreamService extends StreamService<RedisClientType, RedisMultiType
     if (mkStream === 'MKSTREAM') {
       try {
         return (await this.redisClient.xgroup(command, key, groupName, id, mkStream)) === 'OK';
-      } catch (err) {
+      } catch (error) {
         this.logger.info(`Consumer group not created with MKSTREAM for key: ${key} and group: ${groupName}`);
-        throw err;
+        throw error;
       }
     } else {
       try {
         return (await this.redisClient.xgroup(command, key, groupName, id)) === 'OK';
-      } catch (err) {
+      } catch (error) {
         this.logger.info(`Consumer group not created for key: ${key} and group: ${groupName}`);
-        throw err;
+        throw error;
       }
     }
   }
@@ -50,9 +50,9 @@ class IORedisStreamService extends StreamService<RedisClientType, RedisMultiType
   async xadd(key: string, id: string, messageId: string, messageValue: string, multi?: RedisMultiType): Promise<string | RedisMultiType> {
     try {
       return await (multi || this.redisClient).xadd(key, id, messageId, messageValue);
-    } catch (err) {
-      this.logger.error(`Error publishing 'xadd'; key: ${key}`, err);
-      throw err;
+    } catch (error) {
+      this.logger.error(`Error publishing 'xadd'; key: ${key}`, { error });
+      throw error;
     }
   }
 
@@ -79,9 +79,9 @@ class IORedisStreamService extends StreamService<RedisClientType, RedisMultiType
         streamName,
         id
       );
-    } catch (err) {
-      this.logger.error(`Error reading stream data [Stream ${streamName}] [Group ${groupName}]`, err);
-      throw err;
+    } catch (error) {
+      this.logger.error(`Error reading stream data [Stream ${streamName}] [Group ${groupName}]`, { error });
+      throw error;
     }
   }
 
@@ -101,12 +101,12 @@ class IORedisStreamService extends StreamService<RedisClientType, RedisMultiType
       if (consumer) args.push(consumer);
       try {
         return await this.redisClient.call('XPENDING', ...args) as [string, string, number, number][];
-      } catch (err) {
-        this.logger.error('err, args', err, args);
+      } catch (error) {
+        this.logger.error('err, args', { error }, args);
       }
-    } catch (err) {
-      this.logger.error(`Error in retrieving pending messages for [stream ${key}], [group ${group}]`, err);
-      throw err;
+    } catch (error) {
+      this.logger.error(`Error in retrieving pending messages for [stream ${key}], [group ${group}]`, { error });
+      throw error;
     }
   }
 
@@ -120,27 +120,36 @@ class IORedisStreamService extends StreamService<RedisClientType, RedisMultiType
   ): Promise<ReclaimedMessageType> {
     try {
       return await this.redisClient.xclaim(key, group, consumer, minIdleTime, id, ...args) as unknown as ReclaimedMessageType;
-    } catch (err) {
-      this.logger.error(`Error in claiming message with id: ${id} in group: ${group} for key: ${key}`, err);
-      throw err;
+    } catch (error) {
+      this.logger.error(`Error in claiming message with id: ${id} in group: ${group} for key: ${key}`, { error });
+      throw error;
     }
   }
 
   async xack(key: string, group: string, id: string, multi? : RedisMultiType): Promise<number|RedisMultiType> {
     try {
       return await (multi || this.redisClient).xack(key, group, id);
-    } catch (err) {
-      this.logger.error(`Error in acknowledging messages in group: ${group} for key: ${key}`, err);
-      throw err;
+    } catch (error) {
+      this.logger.error(`Error in acknowledging messages in group: ${group} for key: ${key}`, { error });
+      throw error;
     }
   }
 
   async xdel(key: string, id: string, multi? : RedisMultiType): Promise<number|RedisMultiType> {
     try {
       return await (multi || this.redisClient).xdel(key, id);
-    } catch (err) {
-      this.logger.error(`Error in deleting messages with id: ${id} for key: ${key}`, err);
-      throw err;
+    } catch (error) {
+      this.logger.error(`Error in deleting messages with id: ${id} for key: ${key}`, { error });
+      throw error;
+    }
+  }
+
+  async xlen(key: string, multi? : RedisMultiType): Promise<number|RedisMultiType> {
+    try {
+      return await (multi || this.redisClient).xlen(key);
+    } catch (error) {
+      this.logger.error(`Error getting stream depth: ${key}`, { error });
+      throw error;
     }
   }
 }

package/services/stream/clients/redis.ts

@@ -139,6 +139,20 @@ class RedisStreamService extends StreamService<RedisClientType, RedisMultiType>
       throw err;
     }
   }
+
+  async xlen(key: string, multi? : RedisMultiType): Promise<number|RedisMultiType> {
+    try {
+      if (multi) {
+        multi.XLEN(key);
+        return multi;
+      } else {
+        return await this.redisClient.XLEN(key);
+      }
+    } catch (error) {
+      this.logger.error(`Error getting stream depth: ${key}`, { error });
+      throw error;
+    }
+  }
 }
 
 export { RedisStreamService };

package/services/stream/index.ts

@@ -52,6 +52,7 @@ abstract class StreamService<T, U> {
     ...args: string[]): Promise<ReclaimedMessageType>;
   abstract xack(key: string, group: string, id: string, multi?: U): Promise<number|U>;
   abstract xdel(key: string, id: string, multi?: U): Promise<number|U>;
+  abstract xlen(key: string, multi?: U): Promise<number|U>;
 }
 
 export { StreamService };

package/services/task/index.ts

@@ -1,17 +1,20 @@
 import {
   EXPIRE_DURATION,
-  FIDELITY_SECONDS } from '../../modules/enums';
+  FIDELITY_SECONDS, 
+  SCOUT_INTERVAL_SECONDS} from '../../modules/enums';
 import { XSleepFor, sleepFor } from '../../modules/utils';
 import { ILogger } from '../logger';
 import { StoreService } from '../store';
-import { HookInterface } from '../../types/hook';
-import { JobCompletionOptions } from '../../types/job';
+import { HookInterface, HookRule, HookSignal } from '../../types/hook';
+import { JobCompletionOptions, JobState } from '../../types/job';
 import { RedisClient, RedisMulti } from '../../types/redis';
+import { Pipe } from '../pipe';
 
 class TaskService {
   store: StoreService<RedisClient, RedisMulti>;
   logger: ILogger;
   cleanupTimeout: NodeJS.Timeout | null = null;
+  isScout: boolean = false;
 
   constructor(
     store: StoreService<RedisClient, RedisMulti>,
@@ -50,28 +53,59 @@ class TaskService {
     }
   }
 
-  async registerTimeHook(jobId: string, activityId: string, type: 'sleep'|'expire'|'interrupt', inSeconds = FIDELITY_SECONDS, multi?: RedisMulti): Promise<void> {
+  async registerTimeHook(jobId: string, gId: string, activityId: string, type: 'sleep'|'expire'|'interrupt', inSeconds = FIDELITY_SECONDS, multi?: RedisMulti): Promise<void> {
     const awakenTimeSlot = Math.floor((Date.now() + (inSeconds * 1000)) / (FIDELITY_SECONDS * 1000)) * (FIDELITY_SECONDS * 1000); //n second awaken groups
-    await this.store.registerTimeHook(jobId, activityId, type, awakenTimeSlot, multi);
+    await this.store.registerTimeHook(jobId, gId, activityId, type, awakenTimeSlot, multi);
   }
 
-  async processTimeHooks(timeEventCallback: (jobId: string, activityId: string, type: 'sleep'|'expire'|'interrupt') => Promise<void>, listKey?: string): Promise<void> {
-    try {
-      const timeJob = await this.store.getNextTimeJob(listKey);
-      if (timeJob) {
-        const [listKey, jobId, activityId, type] = timeJob;
-        await timeEventCallback(jobId, activityId, type);
-        await sleepFor(0);          
-        this.processTimeHooks(timeEventCallback, listKey);
-      } else {
-        let sleep = XSleepFor(FIDELITY_SECONDS * 1000);
-        this.cleanupTimeout = sleep.timerId;
-        await sleep.promise;
-        this.processTimeHooks(timeEventCallback)
+  /**
+   * Should this engine instance play the role of 'scout' for the quorum.
+   */
+  async shouldScout() {
+    const wasScout = this.isScout;
+    const isScout = wasScout || (this.isScout = await this.store.reserveScoutRole('time'));
+    if (isScout) {
+      if (!wasScout) {
+        setTimeout(() => {
+          this.isScout = false;
+        }, SCOUT_INTERVAL_SECONDS * 1_000);
+      }
+      return true;
+    }
+    return false;
+  }
+
+  async processTimeHooks(timeEventCallback: (jobId: string, gId: string, activityId: string, type: 'sleep'|'expire'|'interrupt') => Promise<void>, listKey?: string): Promise<void> {
+    if (await this.shouldScout()) {
+      try {
+        const timeJob = await this.store.getNextTimeJob(listKey);
+        if (Array.isArray(timeJob)) {
+          //a queue had a job; try again immediately
+          const [listKey, jobId, gId, activityId, type] = timeJob;
+          await timeEventCallback(jobId, gId, activityId, type);
+          await sleepFor(0);
+          this.processTimeHooks(timeEventCallback, listKey);
+        } else if (timeJob) {
+          //a queue was just emptied; try again immediately
+          await sleepFor(0);
+          this.processTimeHooks(timeEventCallback);
+        } else {
+          //all queues are empty; sleep before checking
+          let sleep = XSleepFor(FIDELITY_SECONDS * 1000);
+          this.cleanupTimeout = sleep.timerId;
+          await sleep.promise;
+          this.processTimeHooks(timeEventCallback);
+        }
+      } catch (err) {
+        //todo: retry connect to redis
+        this.logger.error('task-process-timehooks-error', err);
       }
-    } catch (err) {
-      //todo: retry connect to redis
-      this.logger.error('task-process-timehooks-error', err);
+    } else {
+      //didn't get the scout role; try again in 'one-ish' minutes
+      let sleep = XSleepFor(SCOUT_INTERVAL_SECONDS * 1_000 * 2 * Math.random());
+      this.cleanupTimeout = sleep.timerId;
+      await sleep.promise;
+      this.processTimeHooks(timeEventCallback);
     }
   }
 
@@ -81,6 +115,71 @@ class TaskService {
       this.cleanupTimeout = undefined;
     }
   }
+
+  async getHookRule(topic: string): Promise<HookRule | undefined> {
+    const rules = await this.store.getHookRules();
+    return rules?.[topic]?.[0] as HookRule;
+  }
+
+  async registerWebHook(topic: string, context: JobState, dad: string, multi?: RedisMulti): Promise<string> {
+    const hookRule = await this.getHookRule(topic);
+    if (hookRule) {
+      const mapExpression = hookRule.conditions.match[0].expected;
+      const resolved = Pipe.resolve(mapExpression, context);
+      const jobId = context.metadata.jid;
+      const gId = context.metadata.gid;
+      const activityId = hookRule.to;
+      const hook: HookSignal = {
+        topic,
+        resolved,
+        jobId: `${activityId}::${dad}::${gId}::${jobId}`,
+      }
+      await this.store.setHookSignal(hook, multi);
+      return jobId;
+    } else {
+      throw new Error('signaler.registerWebHook:error: hook rule not found');
+    }
+  }
+
+  async processWebHookSignal(topic: string, data: Record<string, unknown>): Promise<[string, string, string, string] | undefined> {
+    const hookRule = await this.getHookRule(topic);
+    if (hookRule) {
+      //NOTE: both formats are supported by the mapping engine:
+      //      `$self.hook.data` OR `$hook.data`
+      const context = { $self: { hook: { data }}, $hook: { data }};
+      const mapExpression = hookRule.conditions.match[0].actual;
+      const resolved = Pipe.resolve(mapExpression, context);
+      const hookSignalId = await this.store.getHookSignal(topic, resolved);
+      if (!hookSignalId) {
+        //messages can be double-processed; not an issue; return undefined
+        //users can also provide a bogus topic; not an issue; return undefined
+        return undefined;
+      }
+      //`aid` is part of composit key, but the hook `topic` is its public interface;
+      // this means that a new version of the graph can be deployed and the
+      // topic can be re-mapped to a different activity id. Outside callers
+      // can adhere to the unchanged contract (calling the same topic),
+      // while the internal system can be updated in real time as necessary.
+      const [_aid, dad, gid, ...jid] = hookSignalId.split('::');
+      return [jid.join('::'), hookRule.to, dad, gid];
+    } else {
+      throw new Error('signal-not-found');
+    }
+  }
+
+  async deleteWebHookSignal(topic: string, data: Record<string, unknown>): Promise<number> {
+    const hookRule = await this.getHookRule(topic);
+    if (hookRule) {
+      //NOTE: both formats are supported by the mapping engine:
+      //      `$self.hook.data` OR `$hook.data`
+      const context = { $self: { hook: { data }}, $hook: { data }};
+      const mapExpression = hookRule.conditions.match[0].actual;
+      const resolved = Pipe.resolve(mapExpression, context);
+      return await this.store.deleteHookSignal(topic, resolved);
+    } else {
+      throw new Error('signaler.process:error: hook rule not found');
+    }
+  }
 }
 
 export { TaskService };

package/services/telemetry/index.ts

@@ -126,20 +126,20 @@ class TelemetryService {
           return result;
         }, {})
       };
-      this.span.setAttributes(namespacedAtts as StringScalarType);
+      this.span?.setAttributes(namespacedAtts as StringScalarType);
     }
   }
 
   setActivityAttributes(attributes: StringScalarType): void {
-    this.span.setAttributes(attributes);
+    this.span?.setAttributes(attributes);
   }
 
   setStreamAttributes(attributes: StringScalarType): void {
-    this.span.setAttributes(attributes);
+    this.span?.setAttributes(attributes);
   }
 
   setJobAttributes(attributes: StringScalarType): void {
-    this.jobSpan.setAttributes(attributes);
+    this.jobSpan?.setAttributes(attributes);
   }
 
   endJobSpan(): void {
@@ -216,11 +216,11 @@ class TelemetryService {
   }
 
   setActivityError(message: string) {
-    this.span.setStatus({ code: SpanStatusCode.ERROR, message });
+    this.span?.setStatus({ code: SpanStatusCode.ERROR, message });
   }
 
   setStreamError(message: string) {
-    this.span.setStatus({ code: SpanStatusCode.ERROR, message });
+    this.span?.setStatus({ code: SpanStatusCode.ERROR, message });
   }
 
   /**

package/services/worker/index.ts

@@ -1,6 +1,6 @@
 import { KeyType } from "../../modules/key";
 import { ILogger } from "../logger";
-import { StreamSignaler } from "../signaler/stream";
+import { Router } from "../router";
 import { StoreService } from '../store';
 import { RedisStoreService as RedisStore } from '../store/clients/redis';
 import { IORedisStoreService as IORedisStore } from '../store/clients/ioredis';
@@ -14,6 +14,7 @@ import { RedisClientType as IORedisClientType } from '../../types/ioredisclient'
 import { HotMeshConfig, HotMeshWorker } from "../../types/hotmesh";
 import {
   QuorumMessage,
+  QuorumProfile,
   SubscriptionCallback } from "../../types/quorum";
 import { RedisClient, RedisMulti } from "../../types/redis";
 import { RedisClientType } from '../../types/redisclient';
@@ -30,7 +31,7 @@ class WorkerService {
   store: StoreService<RedisClient, RedisMulti> | null;
   stream: StreamService<RedisClient, RedisMulti> | null;
   subscribe: SubService<RedisClient, RedisMulti> | null;
-  streamSignaler: StreamSignaler | null;
+  router: Router | null;
   logger: ILogger;
   reporting = false;
 
@@ -66,10 +67,10 @@ class WorkerService {
         await service.subscribe.subscribe(KeyType.QUORUM, service.subscriptionHandler(), appId, service.topic);
         await service.subscribe.subscribe(KeyType.QUORUM, service.subscriptionHandler(), appId, service.guid);
         await service.initStreamChannel(service, worker.stream);
-        service.streamSignaler = service.initStreamSignaler(worker, logger);
+        service.router = service.initRouter(worker, logger);
 
         const key = service.stream.mintKey(KeyType.STREAMS, { appId: service.appId, topic: worker.topic });
-        await service.streamSignaler.consumeMessages(
+        await service.router.consumeMessages(
           key,
           'WORKER',
           service.guid,
@@ -130,8 +131,8 @@ class WorkerService {
     );
   }
 
-  initStreamSignaler(worker: HotMeshWorker, logger: ILogger): StreamSignaler {
-    return new StreamSignaler(
+  initRouter(worker: HotMeshWorker, logger: ILogger): Router {
+    return new Router(
       {
         namespace: this.namespace,
         appId: this.appId,
@@ -153,12 +154,41 @@ class WorkerService {
       self.logger.debug('worker-event-received', { topic, type: message.type });
       if (message.type === 'throttle') {
         self.throttle(message.throttle);
+      } else if(message.type === 'ping') {
+        self.sayPong(self.appId, self.guid, message.originator, message.details);
       }
     };
   }
 
+  async sayPong(appId: string, guid: string, originator: string, details = false) {
+    let profile: QuorumProfile;
+    if (details) {
+      const params = {
+        appId: this.appId,
+        topic: this.topic,
+      };
+
+      profile = {
+        engine_id: this.guid,
+        namespace: this.namespace,
+        app_id: this.appId,
+        worker_topic: this.topic,
+        stream: this.stream.mintKey(KeyType.STREAMS, params),
+      };
+    }
+    this.store.publish(
+      KeyType.QUORUM, 
+      {
+        type: 'pong',
+        guid, originator,
+        profile,
+      },
+      appId,
+    );
+  }
+
   async throttle(delayInMillis: number) {
-    this.streamSignaler.setThrottle(delayInMillis);
+    this.router.setThrottle(delayInMillis);
   }
 }
 

package/types/job.ts

@@ -8,10 +8,12 @@ type ActivityData = {
 
 type JobMetadata = {
   key?: string; //job_key
+  gid: string;  //system assigned guid; ensured created/deleted/created jobs are unique
   jid: string;  //job_id (jid+dad+aid) is composite key for activity
   dad: string;  //dimensional address for the activity (,0,0,1)
   aid: string;  //activity_id as in the YAML file
   pj?: string;  //parent_job_id (pj+pd+pa) is composite key for parent activity
+  pg?: string;  //parent_generational_id (system assigned at trigger inception); pg is the parent job's gid (just in case user created/deleted/created a job with same jid)
   pd?: string;  //parent_dimensional_address
   pa?: string;  //parent_activity_id
   ngn?: string; //engine guid (one time subscriptions)

package/types/quorum.ts

@@ -1,9 +1,20 @@
 import { JobOutput } from "./job";
 
-//used for coordination like version activation
+//used for coordination (like version activation)
+
+export interface QuorumProfile {
+  namespace: string;
+  app_id: string;
+  engine_id: string;
+  worker_topic?: string;
+  stream?: string;
+  stream_depth?: number;
+}
+
 export interface PingMessage {
   type: 'ping';
   originator: string; //guid
+  details?: boolean;  //if true, all endpoints will include their profile
 }
 
 export interface WorkMessage {
@@ -16,11 +27,11 @@ export interface CronMessage {
   originator: string; //guid
 }
 
-//used for coordination like version activation
 export interface PongMessage {
   type: 'pong';
-  originator: string; //clone of originator guid passed in ping
-  guid: string;
+  guid: string;            //call initiator
+  originator: string;      //clone of originator guid passed in ping
+  profile?: QuorumProfile; //contains details about the engine/worker
 }
 
 export interface ActivateMessage {

package/types/redisclient.ts

@@ -6,6 +6,7 @@ interface RedisMultiType {
   XADD(key: string, id: string, fields: any): this;
   XACK(key: string, group: string, id: string): this;
   XDEL(key: string, id: string): this;
+  XLEN(key: string): this;
   HDEL(key: string, itemId: string): this;
   HGET(key: string, itemId: string): this;
   HGETALL(key: string): this;

package/types/stream.ts

@@ -35,12 +35,13 @@ export interface StreamData {
   metadata: {
     guid: string;   //every message is minted with a guid to distinguish retries from new messages
     topic?: string;
-    jid?: string; //is optonal if type is WEBHOOK
-    dad?: string; //dimensional address
+    jid?: string;   //is optional if type is WEBHOOK (system assigned or user assigned)
+    gid?: string;   //is optional if type is WEBHOOK (system assigned job guid)
+    dad?: string;   //dimensional address
     aid: string;
-    trc?: string; //trace id
-    spn?: string; //span id
-    try?: number; //current try count
+    trc?: string;   //trace id
+    spn?: string;   //span id
+    try?: number;   //current try count
   };
   type?: StreamDataType;
   data: Record<string, unknown>;

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

@@ -1,15 +0,0 @@
-import { ILogger } from '../logger';
-import { StoreService } from '../store';
-import { HookRule } from '../../types/hook';
-import { JobState } from '../../types/job';
-import { RedisClient, RedisMulti } from '../../types/redis';
-declare class StoreSignaler {
-    store: StoreService<RedisClient, RedisMulti>;
-    logger: ILogger;
-    constructor(store: StoreService<RedisClient, RedisMulti>, logger: ILogger);
-    getHookRule(topic: string): Promise<HookRule | undefined>;
-    registerWebHook(topic: string, context: JobState, dad: string, multi?: RedisMulti): Promise<string>;
-    processWebHookSignal(topic: string, data: Record<string, unknown>): Promise<[string, string, string] | undefined>;
-    deleteWebHookSignal(topic: string, data: Record<string, unknown>): Promise<number>;
-}
-export { StoreSignaler };