@5minds/node-red-contrib-processcube 0.14.0-fix-error-in-process-instance-query-9aeac9-lyzi0gix → 0.14.0

package/externaltask-input.js

@@ -1,44 +1,24 @@
-const process = require('process');
 const EventEmitter = require('node:events');
 
-const engine_client = require('@5minds/processcube_engine_client');
-
 function showStatus(node, msgCounter) {
     if (msgCounter >= 1) {
-        node.status({ fill: 'blue', shape: 'dot', text: `handling tasks ${msgCounter}` });
+        node.status({fill: "blue", shape: "dot", text: `handling tasks ${msgCounter}.`});
     } else {
-        node.status({ fill: 'blue', shape: 'ring', text: `subcribed ${msgCounter}` });
+        node.status({fill: "blue", shape: "ring", text: `subcribed.`});
     }
 }
 
-function decrCounter(msgCounter) {
-    msgCounter--;
-
-    if (msgCounter < 0) {
-        msgCounter = 0;
-    }
+const started_external_tasks = {};
 
-    return msgCounter;
-}
-
-module.exports = function (RED) {
+module.exports = function(RED) {
     function ExternalTaskInput(config) {
-        RED.nodes.createNode(this, config);
+        RED.nodes.createNode(this,config);
         var node = this;
-        var msgCounter = 0;
         var flowContext = node.context().flow;
-        var nodeContext = node.context();
-
+      
         this.engine = this.server = RED.nodes.getNode(config.engine);
 
-        const engineUrl = this.engine?.url || process.env.ENGINE_URL || 'http://engine:8000';
-
-        var client = nodeContext.get('client');
-
-        if (!client) {
-            nodeContext.set('client', new engine_client.EngineClient(engineUrl));
-            client = nodeContext.get('client');
-        }
+        const client = this.engine.getEngineClient();
 
         var eventEmitter = flowContext.get('emitter');
 
@@ -47,54 +27,126 @@ module.exports = function (RED) {
             eventEmitter = flowContext.get('emitter');
         }
 
-        client.externalTasks
-            .subscribeToExternalTaskTopic(config.topic, async (payload, externalTask) => {
-                msgCounter++;
+        client.externalTasks.subscribeToExternalTaskTopic(
+            config.topic,
+            async (payload, externalTask) => {
 
+                const saveHandleCallback = (data, callback) => {
+                    try {
+                        callback(data);
+                    } catch (error) {
+                        node.error(`Error in callback 'saveHandleCallback': ${error.message}`);
+                    }
+                };
+                
                 return await new Promise((resolve, reject) => {
-                    // TODO: once ist 2x gebunden
-                    eventEmitter.once(`finish-${externalTask.flowNodeInstanceId}`, (result) => {
-                        msgCounter = decrCounter(msgCounter);
 
-                        showStatus(node, msgCounter);
-                        resolve(result);
-                    });
+                    const handleFinishTask = (msg) => {
+                        let result = RED.util.encodeObject(msg.payload);
+
+                        node.log(`handle event for *external task flowNodeInstanceId* '${externalTask.flowNodeInstanceId}' and *processInstanceId* ${externalTask.processInstanceId} with result ${result} on msg._msgid ${msg._msgid}.`);
+
+                        if (externalTask.flowNodeInstanceId) {
+                            delete started_external_tasks[externalTask.flowNodeInstanceId];
+                        }
 
-                    eventEmitter.once(`error-${externalTask.flowNodeInstanceId}`, (msg) => {
-                        msgCounter = decrCounter(msgCounter);
-                        showStatus(node, msgCounter);
+                        showStatus(node, Object.keys(started_external_tasks).length);
 
-                        var result = msg.payload ? msg.payload : msg;
 
-                        reject(result);
+                        //resolve(result);
+                        saveHandleCallback(result, resolve)
+                    };
+
+                    const handleErrorTask = (msg) => {
+
+                        node.log(`handle error event for *external task flowNodeInstanceId* '${externalTask.flowNodeInstanceId}' and *processInstanceId* '${externalTask.processInstanceId}' on *msg._msgid* '${msg._msgid}'.`);
+
+                        if (externalTask.flowNodeInstanceId) {
+                            delete started_external_tasks[externalTask.flowNodeInstanceId];
+                        }
+
+                        showStatus(node, Object.keys(started_external_tasks).length);
+
+
+                        // TODO: with reject, the default error handling is proceed 
+                        // SEE: https://github.com/5minds/ProcessCube.Engine.Client.ts/blob/develop/src/ExternalTaskWorker.ts#L180
+                        // reject(result);
+                        //resolve(msg);
+                        saveHandleCallback(msg, resolve);
+                    };
+
+                    eventEmitter.once(`handle-${externalTask.flowNodeInstanceId}`, (msg, isError = false) => {
+                        node.log(`handle event for *external task flowNodeInstanceId* '${externalTask.flowNodeInstanceId}' and *processInstanceId* '${externalTask.processInstanceId}' with *msg._msgid* '${msg._msgid}' and *isError* '${isError}'`);
+
+                        if (isError) {
+                            handleErrorTask(msg);
+                        } else {
+                            handleFinishTask(msg);
+                        }
                     });
 
-                    showStatus(node, msgCounter);
+                    started_external_tasks[externalTask.flowNodeInstanceId] = externalTask;
+
+                    showStatus(node, Object.keys(started_external_tasks).length);
 
-                    node.send({
-                        topic: externalTask.topic,
+                    let msg = {
+                        _msgid: RED.util.generateId(),
+                        task: RED.util.encodeObject(externalTask),
                         payload: payload,
-                        externalTaskId: externalTask.flowNodeInstanceId,
-                    });
+                        flowNodeInstanceId: externalTask.flowNodeInstanceId
+                    };
+                    
+                    node.log(`Received *external task flowNodeInstanceId* '${externalTask.flowNodeInstanceId}' and *processInstanceId* '${externalTask.processInstanceId}' with *msg._msgid* '${msg._msgid}'`);
+                    
+                    node.send(msg);
                 });
-            })
-            .then(async (externalTaskWorker) => {
-                node.status({ fill: 'blue', shape: 'ring', text: 'subcribed' });
+            },
+            ).then(async externalTaskWorker => {
+                node.status({fill: "blue", shape: "ring", text: "subcribed"});
 
                 externalTaskWorker.identity = node.server.identity;
                 node.server.registerOnIdentityChanged((identity) => {
                     externalTaskWorker.identity = identity;
+                }); 
+
+                // export type WorkerErrorHandler = (errorType: 'fetchAndLock' | 'extendLock' | 'processExternalTask' | 'finishExternalTask', error: Error, externalTask?: ExternalTask<any>) => void;
+                externalTaskWorker.onWorkerError((errorType, error, externalTask) => {
+                    switch (errorType) {
+                        case 'extendLock':
+                        case 'finishExternalTask':
+                        case 'processExternalTask':
+                            node.error(`Worker error ${errorType} for *external task flowNodeInstanceId* '${externalTask.flowNodeInstanceId}' and *processInstanceId* '${externalTask.processInstanceId}': ${error.message}`);
+                    
+                            if (externalTask) {
+                                delete started_external_tasks[externalTask.flowNodeInstanceId];
+                            }
+
+                            showStatus(node, Object.keys(started_external_tasks).length);
+                            break;
+                        default:
+                            node.error(`Worker error ${errorType}: ${error.message}`);
+                            break;
+                    }
                 });
-                await externalTaskWorker.start();
 
-                node.on('close', async () => {
+                try {
+                    externalTaskWorker.start();
+                } catch (error) {
+                    node.error(`Worker start 'externalTaskWorker.start' failed: ${error.message}`);
+                }
+
+                node.on("close", () => {
                     try {
                         externalTaskWorker.stop();
                     } catch {
-                        console.warn('Client close failed');
+                        node.error('Client close failed');
                     }
                 });
-            });
+            }
+        ).catch((error) => {
+            node.error(`Error in subscribeToExternalTaskTopic: ${error.message}`);
+        });
     }
-    RED.nodes.registerType('externaltask-input', ExternalTaskInput);
-};
+
+    RED.nodes.registerType("externaltask-input", ExternalTaskInput);
+}

package/externaltask-output.html

@@ -1,26 +1,36 @@
 <script type="text/javascript">
-    RED.nodes.registerType('externaltask-output', {
+    RED.nodes.registerType('externaltask-output',{
         category: 'ProcessCube',
         color: '#02AFD6',
         defaults: {
-            name: { value: '' },
+            name: {value:""}
         },
         inputs: 1,
         outputs: 0,
-        icon: 'font-awesome/fa-envelope',
-        label: function () {
-            return this.name || 'externaltask-output';
-        },
+        icon: "font-awesome/fa-envelope",
+        label: function() {
+            return this.name||"externaltask-output";
+        }
     });
 </script>
 
 <script type="text/html" data-template-name="externaltask-output">
     <div class="form-row">
         <label for="node-input-name"><i class="fa fa-tag"></i> Name</label>
-        <input type="text" id="node-input-name" placeholder="Name" />
+        <input type="text" id="node-input-name" placeholder="Name">
     </div>
 </script>
 
-<script type="text/html" data-help-name="externaltask-output">
-    <p>A node which response to an External Task of https://processcube.io</p>
-</script>
+<script type="text/markdown" data-help-name="externaltask-output">
+Used to complete the external task. The `msg.payload` is returned to the ProcessCube 
+engine as the result of the external task.
+
+## Inputs
+
+: payload (Object) : Returned to the ProcessCube engine as the result of the external task
+
+### References
+
+- [The ProcessCube Developer Network](https://processcube.io) - All documentation for the ProcessCube&copy; platform
+- [Node-RED Integration in ProcessCube&copy;](https://processcube.io/docs/node-red) - Node-RED integration in ProcessCube&copy;
+</script>

package/externaltask-output.js

@@ -1,20 +1,21 @@
-module.exports = function (RED) {
+module.exports = function(RED) {
     function ExternalTaskOutput(config) {
-        RED.nodes.createNode(this, config);
+        RED.nodes.createNode(this,config);
         var node = this;
 
         var flowContext = node.context().flow;
         var eventEmitter = flowContext.get('emitter');
 
-        node.on('input', function (msg) {
-            const externalTaskId = msg.externalTaskId;
+        node.on('input', function(msg) {
+            
+            const flowNodeInstanceId = msg.flowNodeInstanceId;
 
-            if (!externalTaskId) {
-                node.error('Error: The message did not contain the required external task id.', msg);
-            }
+            if (!flowNodeInstanceId) {
+               node.error('Error: The message did not contain the required external task id.', msg);
+            }  
 
-            eventEmitter.emit(`finish-${externalTaskId}`, msg.payload);
-        });
+            eventEmitter.emit(`handle-${flowNodeInstanceId}`, msg, false);
+        });     
     }
-    RED.nodes.registerType('externaltask-output', ExternalTaskOutput);
-};
+    RED.nodes.registerType("externaltask-output", ExternalTaskOutput);
+}

package/message-event-trigger.html

@@ -1,41 +1,41 @@
 <script type="text/javascript">
-    RED.nodes.registerType('message-event-trigger', {
+    RED.nodes.registerType('message-event-trigger',{
         category: 'ProcessCube',
         color: '#02AFD6',
         defaults: {
-            name: { value: '' },
-            engine: { value: '', type: 'processcube-engine-config' },
-            messagename: { value: '', required: true },
-            processInstanceId: { value: '' },
+            name: {value: ""},
+            engine: {value: "", type: "processcube-engine-config"},
+            messagename: {value: "", required: true},
+            processInstanceId: {value:""}
         },
         inputs: 1,
         outputs: 1,
-        icon: 'font-awesome/fa-envelope-open',
-        label: function () {
-            return this.name || 'message-event-trigger';
-        },
+        icon: "font-awesome/fa-envelope-open",
+        label: function() {
+            return this.name||"message-event-trigger";
+        }
     });
 </script>
 
 <script type="text/html" data-template-name="message-event-trigger">
     <div class="form-row">
         <label for="node-input-name"><i class="fa fa-tag"></i> Name</label>
-        <input type="text" id="node-input-name" placeholder="Name" />
+        <input type="text" id="node-input-name" placeholder="Name">
     </div>
     <div class="form-row">
         <label for="node-input-engine"><i class="fa fa-tag"></i> Engine</label>
-        <input type="text" id="node-input-engine" placeholder="Engine" />
+        <input type="text" id="node-input-engine" placeholder="Engine">
     </div>
     <div class="form-row">
         <label for="node-input-messagename"><i class="fa fa-tag"></i> Message Name</label>
-        <input type="text" id="node-input-messagename" placeholder="Name of the Message-Event" />
+        <input type="text" id="node-input-messagename" placeholder="Name of the Message-Event">
     </div>
     <div class="form-row">
         <label for="node-input-processinstanceid"><i class="fa fa-tag"></i> Process Instance Id</label>
-        <input type="text" id="node-input-processinstanceid" placeholder="Id of the recipient process instance" />
+        <input type="text" id="node-input-processinstanceid" placeholder="Id of the recipient process instance">
     </div>
 </script>
 
 <script type="text/html" data-help-name="externaltask-input">
     <p>A node which emmits an message event to the Engine.</p>
-</script>
+</script>

package/message-event-trigger.js

@@ -1,25 +1,17 @@
-const process = require('process');
+const process = require("process");
 
-const engine_client = require('@5minds/processcube_engine_client');
+const engine_client = require("@5minds/processcube_engine_client");
 
 module.exports = function (RED) {
     function MessageEventTrigger(config) {
         RED.nodes.createNode(this, config);
         var node = this;
-        var nodeContext = node.context();
 
         this.engine = this.server = RED.nodes.getNode(config.engine);
 
-        const engineUrl = this.engine?.url || process.env.ENGINE_URL || 'http://engine:8000';
+        const client = this.engine.getEngineClient();
 
-        var client = nodeContext.get('client');
-
-        if (!client) {
-            nodeContext.set('client', new engine_client.EngineClient(engineUrl));
-            client = nodeContext.get('client');
-        }
-
-        node.on('input', function (msg) {
+        node.on("input", function (msg) {
             client.events
                 .triggerMessageEvent(config.messagename, {
                     processInstanceId: config.processinstanceid,
@@ -30,12 +22,16 @@ module.exports = function (RED) {
                     msg.payload = result;
 
                     node.send(msg);
-                    node.status({ fill: 'blue', shape: 'dot', text: `message event triggered` });
+                    node.status({
+                        fill: "blue",
+                        shape: "dot",
+                        text: `message event triggered`,
+                    });
                 })
                 .catch((error) => {
                     node.error(error);
                 });
         });
     }
-    RED.nodes.registerType('message-event-trigger', MessageEventTrigger);
+    RED.nodes.registerType("message-event-trigger", MessageEventTrigger);
 };