@5minds/node-red-contrib-processcube 0.14.0-develop-7fe136-lygsbbpi → 0.14.0-error-handling-in-process-instance-query-and-add-prettier-8b2f33-lz08cr3v

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;
-    }
-
-    return msgCounter;
-}
+const started_external_tasks = {};
 
-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,53 +27,130 @@ 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];
+                        }
+
+                        showStatus(node, Object.keys(started_external_tasks).length);
+
+                        //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);
+                        }
                     });
 
-                    eventEmitter.once(`error-${externalTask.flowNodeInstanceId}`, (msg) => {
-                        msgCounter = decrCounter(msgCounter);
-                        showStatus(node, msgCounter);
+                    started_external_tasks[externalTask.flowNodeInstanceId] = externalTask;
 
-                        var result = msg.payload ? msg.payload : msg;
+                    showStatus(node, Object.keys(started_external_tasks).length);
 
-                        reject(result);
-                    });
+                    let msg = {
+                        _msgid: RED.util.generateId(),
+                        task: RED.util.encodeObject(externalTask),
+                        payload: payload,
+                        flowNodeInstanceId: externalTask.flowNodeInstanceId,
+                    };
+
+                    node.log(
+                        `Received *external task flowNodeInstanceId* '${externalTask.flowNodeInstanceId}' and *processInstanceId* '${externalTask.processInstanceId}' with *msg._msgid* '${msg._msgid}'`,
+                    );
 
-                    showStatus(node, msgCounter);
-                    
-                    node.send({topic: externalTask.topic, payload: payload, externalTaskId: externalTask.flowNodeInstanceId});
+                    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;
-                }); 
-                await externalTaskWorker.start();
+                });
 
-                node.on("close", async () => {
+                // 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;
+                    }
+                });
+
+                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,21 +1,20 @@
-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

@@ -2,44 +2,36 @@ const process = require('process');
 
 const engine_client = require('@5minds/processcube_engine_client');
 
-module.exports = function(RED) {
+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';
-
-        var client = nodeContext.get('client');
-
-        if (!client) {
-            nodeContext.set('client', new engine_client.EngineClient(engineUrl));
-            client = nodeContext.get('client');
-        } 
-
-        node.on('input', function(msg) {
-
-            client.events.triggerMessageEvent(
-                config.messagename,
-                {
-                  processInstanceId: config.processinstanceid,
-                  payload: msg.payload,
-                  identity: node.server.identity
-                }
-            
-            ).then((result) => {
-
-                msg.payload = result;
-            
-                node.send(msg);
-                node.status({fill: "blue", shape: "dot", text: `message event triggered`});
-            
-            }).catch((error) => {
-                node.error(error);
-            });
+        const client = this.engine.getEngineClient();
+
+        node.on('input', function (msg) {
+            client.events
+                .triggerMessageEvent(config.messagename, {
+                    processInstanceId: config.processinstanceid,
+                    payload: msg.payload,
+                    identity: node.server.identity,
+                })
+                .then((result) => {
+                    msg.payload = result;
+
+                    node.send(msg);
+                    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);
+};