@hotmeshio/hotmesh 0.0.35 → 0.0.37

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';
@@ -30,7 +30,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 +66,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 +130,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,
@@ -158,7 +158,7 @@ class WorkerService {
   }
 
   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/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 };

package/build/services/signaler/store.js

@@ -1,68 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.StoreSignaler = void 0;
-const pipe_1 = require("../pipe");
-class StoreSignaler {
-    constructor(store, logger) {
-        this.store = store;
-        this.logger = logger;
-    }
-    async getHookRule(topic) {
-        const rules = await this.store.getHookRules();
-        return rules?.[topic]?.[0];
-    }
-    async registerWebHook(topic, context, dad, multi) {
-        const hookRule = await this.getHookRule(topic);
-        if (hookRule) {
-            const mapExpression = hookRule.conditions.match[0].expected;
-            const resolved = pipe_1.Pipe.resolve(mapExpression, context);
-            const jobId = context.metadata.jid;
-            const hook = {
-                topic,
-                resolved,
-                //hookSignalId is composed of `<dad>::<jid>`
-                jobId: `${dad}::${jobId}`,
-            };
-            await this.store.setHookSignal(hook, multi);
-            return jobId;
-        }
-        else {
-            throw new Error('signaler.registerWebHook:error: hook rule not found');
-        }
-    }
-    async processWebHookSignal(topic, data) {
-        const hookRule = await this.getHookRule(topic);
-        if (hookRule) {
-            //NOTE: both formats are supported: $self.hook.data OR $hook.data
-            const context = { $self: { hook: { data } }, $hook: { data } };
-            const mapExpression = hookRule.conditions.match[0].actual;
-            const resolved = pipe_1.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;
-            }
-            const [dad, jid] = hookSignalId.split('::');
-            //return [jid, aid, dad]
-            return [jid, hookRule.to, dad];
-        }
-        else {
-            throw new Error('signal-not-found');
-        }
-    }
-    async deleteWebHookSignal(topic, data) {
-        const hookRule = await this.getHookRule(topic);
-        if (hookRule) {
-            //NOTE: both formats are supported: $self.hook.data OR $hook.data
-            const context = { $self: { hook: { data } }, $hook: { data } };
-            const mapExpression = hookRule.conditions.match[0].actual;
-            const resolved = pipe_1.Pipe.resolve(mapExpression, context);
-            return await this.store.deleteHookSignal(topic, resolved);
-        }
-        else {
-            throw new Error('signaler.process:error: hook rule not found');
-        }
-    }
-}
-exports.StoreSignaler = StoreSignaler;

package/services/signaler/store.ts

@@ -1,76 +0,0 @@
-import { ILogger } from '../logger';
-import { StoreService } from '../store';
-import { HookRule, HookSignal } from '../../types/hook';
-import { JobState } from '../../types/job';
-import { RedisClient, RedisMulti } from '../../types/redis';
-import { Pipe } from '../pipe';
-
-class StoreSignaler {
-  store: StoreService<RedisClient, RedisMulti>;
-  logger: ILogger
-
-  constructor(store: StoreService<RedisClient, RedisMulti>, logger: ILogger) {
-    this.store = store;
-    this.logger = logger;
-  }
-
-  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 hook: HookSignal = {
-        topic,
-        resolved,
-        //hookSignalId is composed of `<dad>::<jid>`
-        jobId: `${dad}::${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] | undefined> {
-    const hookRule = await this.getHookRule(topic);
-    if (hookRule) {
-      //NOTE: both formats are supported: $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;
-      }
-      const [dad, jid] = hookSignalId.split('::');
-      //return [jid, aid, dad]
-      return [jid, hookRule.to, dad];
-    } 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: $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 { StoreSignaler };