@hotmeshio/hotmesh 0.2.3 → 0.2.4

package/build/package.json

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

package/build/services/engine/index.js

@@ -92,6 +92,7 @@ class EngineService {
             reclaimDelay: config.engine.reclaimDelay,
             reclaimCount: config.engine.reclaimCount,
             throttle,
+            readonly: config.engine.readonly,
         }, this.stream, this.store, this.logger);
     }
     async fetchAndVerifyVID(vid, count = 0) {

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

@@ -1,21 +1,21 @@
 import { HotMesh } from '../hotmesh';
-import { MeshCallConnectParams, MeshCallCronParams, MeshCallExecParams, MeshCallFlushParams, MeshCallInterruptParams } from '../../types/meshcall';
+import { MeshCallConnectParams, MeshCallCronParams, MeshCallExecParams, MeshCallFlushParams, MeshCallInstanceOptions, MeshCallInterruptParams } from '../../types/meshcall';
 import { RedisConfig } from '../../types';
 declare class MeshCall {
     static workers: Map<string, HotMesh | Promise<HotMesh>>;
     static engines: Map<string, HotMesh | Promise<HotMesh>>;
     static connections: Map<string, any>;
     constructor();
-    static findFirstMatching(workers: Map<string, HotMesh | Promise<HotMesh>>, namespace: string, config: RedisConfig): Promise<HotMesh | void>;
-    static getHotMeshClient: (namespace: string, connection: RedisConfig) => Promise<HotMesh>;
+    static findFirstMatching(targets: Map<string, HotMesh | Promise<HotMesh>>, namespace: string, config: RedisConfig, options?: MeshCallInstanceOptions): Promise<HotMesh | void>;
+    static getHotMeshClient: (namespace: string, connection: RedisConfig, options?: MeshCallInstanceOptions) => Promise<HotMesh>;
     static verifyWorkflowActive(hotMesh: HotMesh, appId?: string, count?: number): Promise<boolean>;
     static activateWorkflow(hotMesh: HotMesh, appId?: string, version?: string): Promise<void>;
-    static getInstance(namespace: string, redis: RedisConfig): Promise<HotMesh>;
+    static getInstance(namespace: string, redis: RedisConfig, options?: MeshCallInstanceOptions): Promise<HotMesh>;
     static connect(params: MeshCallConnectParams): Promise<HotMesh>;
     static exec<U>(params: MeshCallExecParams): Promise<U>;
     static flush(params: MeshCallFlushParams): Promise<void>;
     static cron(params: MeshCallCronParams): Promise<boolean>;
-    static interrupt(params: MeshCallInterruptParams): Promise<void>;
+    static interrupt(params: MeshCallInterruptParams): Promise<boolean>;
     static shutdown(): Promise<void>;
 }
 export { MeshCall };

package/build/services/meshcall/index.js

@@ -14,11 +14,15 @@ const cron_1 = require("../pipe/functions/cron");
 const factory_1 = require("./schemas/factory");
 class MeshCall {
     constructor() { }
-    static async findFirstMatching(workers, namespace = key_1.HMNS, config) {
-        for (const [id, hotMeshInstance] of workers) {
-            if ((await hotMeshInstance).namespace === namespace) {
+    static async findFirstMatching(targets, namespace = key_1.HMNS, config, options = {}) {
+        for (const [id, hotMeshInstance] of targets) {
+            const hotMesh = await hotMeshInstance;
+            const appId = hotMesh.engine.appId;
+            if (appId === namespace) {
                 if (id.startsWith((0, utils_1.hashOptions)(config.options))) {
-                    return hotMeshInstance;
+                    if (Boolean(options.readonly) == Boolean(hotMesh.engine.router.readonly)) {
+                        return hotMeshInstance;
+                    }
                 }
             }
         }
@@ -60,12 +64,15 @@ class MeshCall {
             }
         }
     }
-    static async getInstance(namespace, redis) {
-        let hotMeshInstance = await MeshCall.findFirstMatching(MeshCall.workers, namespace, redis);
+    static async getInstance(namespace, redis, options = {}) {
+        let hotMeshInstance;
+        if (!options.readonly) {
+            hotMeshInstance = await MeshCall.findFirstMatching(MeshCall.workers, namespace, redis, options);
+        }
         if (!hotMeshInstance) {
-            hotMeshInstance = await MeshCall.findFirstMatching(MeshCall.engines, namespace, redis);
+            hotMeshInstance = await MeshCall.findFirstMatching(MeshCall.engines, namespace, redis, options);
             if (!hotMeshInstance) {
-                hotMeshInstance = (await MeshCall.getHotMeshClient(namespace, redis));
+                hotMeshInstance = (await MeshCall.getHotMeshClient(namespace, redis, options));
             }
         }
         return hotMeshInstance;
@@ -131,7 +138,7 @@ class MeshCall {
         await hotMeshInstance.scrub(params.id ?? params?.options?.id);
     }
     static async cron(params) {
-        try {
+        if (params.callback) {
             await MeshCall.connect({
                 logLevel: params.logLevel,
                 guid: params.guid,
@@ -140,22 +147,26 @@ class MeshCall {
                 callback: params.callback,
                 namespace: params.namespace,
             });
-            const TOPIC = `${params.namespace ?? key_1.HMNS}.cron`;
-            let delay = params.options.delay
+        }
+        const TOPIC = `${params.namespace ?? key_1.HMNS}.cron`;
+        const maxCycles = params.options.maxCycles ?? 100000;
+        let interval = enums_1.HMSH_FIDELITY_SECONDS;
+        let delay;
+        let cron;
+        if ((0, utils_1.isValidCron)(params.options.interval)) {
+            cron = params.options.interval;
+            const nextDelay = new cron_1.CronHandler().nextDelay(cron);
+            delay = nextDelay > 0 ? nextDelay : undefined;
+        }
+        else {
+            const seconds = (0, ms_1.default)(params.options.interval) / 1000;
+            interval = Math.max(seconds, enums_1.HMSH_FIDELITY_SECONDS);
+            delay = params.options.delay
                 ? (0, ms_1.default)(params.options.delay) / 1000
                 : undefined;
-            let cron;
-            let interval = enums_1.HMSH_FIDELITY_SECONDS;
-            if ((0, utils_1.isValidCron)(params.options.interval)) {
-                cron = params.options.interval;
-                delay = Math.max(new cron_1.CronHandler().nextDelay(cron), 0);
-            }
-            else {
-                const seconds = (0, ms_1.default)(params.options.interval) / 1000;
-                interval = Math.max(seconds, enums_1.HMSH_FIDELITY_SECONDS);
-            }
-            const maxCycles = params.options.maxCycles ?? 1000000;
-            const hotMeshInstance = await MeshCall.getInstance(params.namespace, params.redis);
+        }
+        try {
+            const hotMeshInstance = await MeshCall.getInstance(params.namespace, params.redis, { readonly: params.callback ? false : true, guid: params.guid });
             await hotMeshInstance.pub(TOPIC, {
                 id: params.options.id,
                 topic: params.topic,
@@ -176,7 +187,13 @@ class MeshCall {
     }
     static async interrupt(params) {
         const hotMeshInstance = await MeshCall.getInstance(params.namespace, params.redis);
-        await hotMeshInstance.interrupt(`${params.namespace ?? key_1.HMNS}.cron`, params.options.id, { throw: false, expire: 60 });
+        try {
+            await hotMeshInstance.interrupt(`${params.namespace ?? key_1.HMNS}.cron`, params.options.id, { throw: false, expire: 1 });
+        }
+        catch (error) {
+            return false;
+        }
+        return true;
     }
     static async shutdown() {
         for (const [_, hotMeshInstance] of MeshCall.workers) {
@@ -193,7 +210,7 @@ _a = MeshCall;
 MeshCall.workers = new Map();
 MeshCall.engines = new Map();
 MeshCall.connections = new Map();
-MeshCall.getHotMeshClient = async (namespace, connection) => {
+MeshCall.getHotMeshClient = async (namespace, connection, options = {}) => {
     const optionsHash = (0, utils_1.hashOptions)(connection.options);
     const targetNS = namespace ?? key_1.HMNS;
     const connectionNS = `${optionsHash}.${targetNS}`;
@@ -203,6 +220,7 @@ MeshCall.getHotMeshClient = async (namespace, connection) => {
         return hotMeshClient;
     }
     const hotMeshClient = hotmesh_1.HotMesh.init({
+        guid: options.guid,
         appId: targetNS,
         logLevel: enums_1.HMSH_LOGLEVEL,
         engine: {
@@ -210,6 +228,7 @@ MeshCall.getHotMeshClient = async (namespace, connection) => {
                 class: connection.class,
                 options: connection.options,
             },
+            readonly: options.readonly,
         },
     });
     MeshCall.engines.set(connectionNS, hotMeshClient);

package/build/services/meshcall/schemas/factory.js

@@ -72,8 +72,6 @@ const getWorkflowYAML = (appId = key_1.HMNS, version = exports.VERSION) => {
 
     - subscribes: ${appId}.cron
 
-      expire: 120
-
       input:
         schema:
           type: object
@@ -123,6 +121,8 @@ const getWorkflowYAML = (appId = key_1.HMNS, version = exports.VERSION) => {
               properties:
                 sleepSeconds:
                   type: number
+                iterationCount:
+                  type: number
             maps:
               sleepSeconds:
                 '@pipe':

package/build/services/router/index.js

@@ -74,8 +74,10 @@ class Router {
         });
     }
     async consumeMessages(stream, group, consumer, callback) {
-        if (this.readonly)
+        if (this.readonly) {
+            this.logger.info(`router-stream-readonly`, { group, consumer, stream });
             return;
+        }
         this.logger.info(`router-stream-starting`, { group, consumer, stream });
         Router.instances.add(this);
         this.shouldConsume = true;

package/build/types/meshcall.d.ts

@@ -46,13 +46,17 @@ interface MeshCallCronParams {
     topic: string;
     redis: RedisConfig;
     args: any[];
-    callback: (...args: any[]) => any;
+    callback?: (...args: any[]) => any;
     options: MeshCallCronOptions;
 }
+interface MeshCallInstanceOptions {
+    readonly?: boolean;
+    guid?: string;
+}
 interface MeshCallInterruptParams {
     namespace?: string;
     topic: string;
     redis: RedisConfig;
     options: MeshCallInterruptOptions;
 }
-export { MeshCallConnectParams, MeshCallExecParams, MeshCallCronParams, MeshCallExecOptions, MeshCallCronOptions, MeshCallInterruptOptions, MeshCallInterruptParams, MeshCallFlushOptions, MeshCallFlushParams, };
+export { MeshCallConnectParams, MeshCallExecParams, MeshCallCronParams, MeshCallExecOptions, MeshCallCronOptions, MeshCallInterruptOptions, MeshCallInterruptParams, MeshCallFlushOptions, MeshCallFlushParams, MeshCallInstanceOptions, };

package/package.json

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

package/types/meshcall.ts

@@ -153,15 +153,31 @@ interface MeshCallCronParams {
    */
   args: any[];
   /**
-   * linked worker function to run
+   * linked worker function to run; if not provided, the system will
+   * attempt to start the cron job using the topic, but a new
+   * worker will not be created. This is useful for spawning a cron job
+   * from an ephemeral node process.
    */
-  callback: (...args: any[]) => any;
+  callback?: (...args: any[]) => any;
   /**
    * Options for the cron job
    */
   options: MeshCallCronOptions;
 }
 
+interface MeshCallInstanceOptions {
+  /**
+   * if true, the connection to HotMesh will be in readonly mode
+   * and the instantiated client will not route messages
+   * @default false
+   */
+  readonly?: boolean;
+  /**
+   * Idempotent GUID for the worker and engine
+   */
+  guid?: string;
+}
+
 interface MeshCallInterruptParams {
   /**
    * namespace for grouping common functions
@@ -191,4 +207,5 @@ export {
   MeshCallInterruptParams,
   MeshCallFlushOptions,
   MeshCallFlushParams,
+  MeshCallInstanceOptions,
 };