@hotmeshio/hotmesh 0.0.52 → 0.0.54

package/build/services/durable/handle.js

@@ -1,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.WorkflowHandleService = void 0;
-const enums_1 = require("../../modules/enums");
 const exporter_1 = require("./exporter");
 class WorkflowHandleService {
     constructor(hotMesh, workflowTopic, workflowId) {
@@ -10,14 +9,14 @@ class WorkflowHandleService {
         this.hotMesh = hotMesh;
         this.exporter = new exporter_1.ExporterService(this.hotMesh.appId, this.hotMesh.engine.store, this.hotMesh.engine.logger);
     }
-    async export() {
-        return this.exporter.export(this.workflowId);
+    async export(options) {
+        return this.exporter.export(this.workflowId, options);
     }
     /**
      * Sends a signal to the workflow. This is a way to send
      * a message to a workflow that is paused due to having
-     * executed a `waitForSignal` workflow extension. Awakens
-     * the workflow if no other signals are pending.
+     * executed `Durable.workflow.waitFor`. The workflow
+     * will awaken if no other signals are pending.
      */
     async signal(signalId, data) {
         await this.hotMesh.hook(`${this.hotMesh.appId}.wfs.signal`, { id: signalId, data });
@@ -63,68 +62,82 @@ class WorkflowHandleService {
         return await this.hotMesh.interrupt(`${this.hotMesh.appId}.execute`, this.workflowId, options);
     }
     /**
-     * Awaits for the workflow to complete and returns the result. If
-     * the workflow thows and error, this method will likewise throw
-     * an error.
+     * Waits for the workflow to complete and returns the result. If
+     * the workflow response includes an error, this method will rethrow
+     * the error, including the stack trace if available.
+     * Wrap calls in a try/catch as necessary to avoid unhandled exceptions.
      */
-    async result(loadState) {
-        if (loadState) {
-            const state = await this.hotMesh.getState(`${this.hotMesh.appId}.execute`, this.workflowId);
-            if (!state.data && state.metadata.err) {
-                throw new Error(JSON.parse(state.metadata.err));
-            }
-            if (state?.data?.done) {
-                //child flows are never 'done'; they use a hook
-                //that only closes upon parent flow completion.
-                return state.data.response;
-            }
-        }
-        let status = await this.hotMesh.getStatus(this.workflowId);
+    async result(config) {
         const topic = `${this.hotMesh.appId}.executed.${this.workflowId}`;
-        return new Promise((resolve, reject) => {
-            let isResolved = false;
-            //common fulfill/unsubscribe
+        let isResolved = false;
+        return new Promise(async (resolve, reject) => {
+            /**
+             * rejects/resolves the promise based on the `throwOnError`
+             * default behavior is to throw if error
+             */
+            const safeReject = (err) => {
+                if (config?.throwOnError === false) {
+                    return resolve(err);
+                }
+                reject(err);
+            };
+            /**
+             * Common completion function that unsubscribes from the topic/returns
+             */
             const complete = async (response, err) => {
                 if (isResolved)
                     return;
                 isResolved = true;
-                this.hotMesh.unsub(topic);
                 if (err) {
-                    return reject(JSON.parse(err));
+                    return safeReject(err);
                 }
                 else if (!response) {
                     const state = await this.hotMesh.getState(`${this.hotMesh.appId}.execute`, this.workflowId);
-                    if (state.metadata.err) {
-                        const error = JSON.parse(state.metadata.err);
-                        if (error.code === enums_1.HMSH_CODE_INTERRUPT || !state.data) {
-                            return reject({ ...error, job_id: this.workflowId });
-                        }
+                    if (state.data?.done && !state.data?.$error) {
+                        return resolve(state.data.response);
+                    }
+                    else if (state.data?.$error) {
+                        return safeReject(state.data.$error);
+                    }
+                    else if (state.metadata.err) {
+                        return safeReject(JSON.parse(state.metadata.err));
                     }
                     response = state.data?.response;
                 }
                 resolve(response);
             };
-            //check for done
-            if (status <= 0) {
-                return complete();
+            //more expensive; fetches the entire job, not just the `status`
+            if (config?.state) {
+                const state = await this.hotMesh.getState(`${this.hotMesh.appId}.execute`, this.workflowId);
+                if (state?.data?.done && !state.data?.$error) {
+                    return complete(state.data.response);
+                }
+                else if (state.data?.$error) {
+                    return complete(null, state.data.$error);
+                }
+                else if (state.metadata.err) {
+                    return complete(null, JSON.parse(state.metadata.err));
+                }
             }
-            //subscribe to topic
-            this.hotMesh.sub(topic, async (topic, state) => {
-                if (state.metadata.err) {
+            //subscribe to 'done' topic
+            this.hotMesh.sub(topic, async (_topic, state) => {
+                this.hotMesh.unsub(topic);
+                if (state.data.done && !state.data?.$error) {
+                    await complete(state.data?.response);
+                }
+                else if (state.data?.$error) {
+                    return complete(null, state.data.$error);
+                }
+                else if (state.metadata.err) {
                     const error = JSON.parse(state.metadata.err);
-                    if (error.code === enums_1.HMSH_CODE_INTERRUPT || !state.data) {
-                        return await complete(null, state.metadata.err);
-                    }
+                    return await complete(null, error);
                 }
-                await complete(state.data?.response);
             });
-            //resolve for race condition
-            setTimeout(async () => {
-                status = await this.hotMesh.getStatus(this.workflowId);
-                if (status <= 0) {
-                    await complete();
-                }
-            }, 0);
+            //check state in case completed during wiring
+            const status = await this.hotMesh.getStatus(this.workflowId);
+            if (status <= 0) {
+                await complete();
+            }
         });
     }
 }

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

@@ -1,6 +1,5 @@
 import { ClientService } from './client';
 import { ConnectionService } from './connection';
-import { MeshOSService } from './meshos';
 import { Search } from './search';
 import { WorkerService } from './worker';
 import { WorkflowService } from './workflow';
@@ -9,7 +8,6 @@ export declare const Durable: {
     Client: typeof ClientService;
     Connection: typeof ConnectionService;
     Search: typeof Search;
-    MeshOS: typeof MeshOSService;
     Worker: typeof WorkerService;
     workflow: typeof WorkflowService;
     /**

package/build/services/durable/index.js

@@ -3,7 +3,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Durable = void 0;
 const client_1 = require("./client");
 const connection_1 = require("./connection");
-const meshos_1 = require("./meshos");
 const search_1 = require("./search");
 const worker_1 = require("./worker");
 const workflow_1 = require("./workflow");
@@ -12,7 +11,6 @@ exports.Durable = {
     Client: client_1.ClientService,
     Connection: connection_1.ConnectionService,
     Search: search_1.Search,
-    MeshOS: meshos_1.MeshOSService,
     Worker: worker_1.WorkerService,
     workflow: workflow_1.WorkflowService,
     /**

package/build/services/durable/schemas/factory.d.ts

@@ -0,0 +1,33 @@
+/**
+ *********** HOTMESH 'DURABLE' MODULE APPLICATION GRAPH **********
+ *
+ * This HotMesh application spec uses 50 activities and 25 transitions
+ * to model and emulate the Temporal Application & Query servers using
+ * Redis as the backend.
+ *
+ * It's particularly useful for organizations with high-speed, high-volume
+ * use cases as it uses in-memory Redis Streams for transactional,
+ * workflow processing, while adhering to Temporal's developer-friendly syntax.
+ *
+ * This YAML file can also serve as a useful starting point for building
+ * Integration/BPM/Workflow servers in general (MuleSoft, etc) without the need
+ * for a physical application server.
+ *
+ * Possible use cases include:
+ * * Orchestration servers
+ * * Integration servers
+ * * BPMN engines
+ * * Reentrant process servers
+ * * Service Meshes
+ * * Master Data Management systems
+ */
+declare const APP_VERSION = "1";
+declare const APP_ID = "durable";
+/**
+ * returns a new durable workflow schema
+ * @param {string} app - app name (e.g., 'durable')
+ * @param {string} version - number as string (e.g., '1')
+ * @returns {string} HotMesh App YAML
+ */
+declare const getWorkflowYAML: (app: string, version: string) => string;
+export { getWorkflowYAML, APP_VERSION, APP_ID, };