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

package/Dockerfile

@@ -1,4 +1,4 @@
-FROM node:20 as builder
+FROM node:20 AS builder
 
 COPY ./ /src/node-red-contrib-processcube
 

package/docker-compose.yml

@@ -5,12 +5,17 @@ services:
       context: .
     ports:
       - "1880:1880"
+      - "9229:9229"
     environment:
       - TZ=Europe/Berlin
       - ENGINE_URL=http://engine:8000
       - FLOWS=/nodered/node-red-contrib-processcube-flows.json
     volumes:
       - ./nodered/:/nodered/
+      - ./examples/:/examples/
+    depends_on:
+      - engine
+      - authority
   
   engine:
     image: 5minds/processcube_engine:2024-1
@@ -19,9 +24,16 @@ services:
     volumes:
       - ./processes:/processes:ro
     environment:
+      application__name: Engine for Node-RED contrib
       iam__baseUrl: http://authority:11560
       iam__allowAnonymousRootAccess: true
     command: --seed-dir=/processes --port 8000
+    depends_on:
+      - authority
+    healthcheck:
+      test: bash -c "[ -f /tmp/healthy ]"
+      timeout: 1s
+      retries: 20      
 
   authority:
     image: 5minds/processcube_authority:3.0.4

package/examples/External-Task-Sample.json

@@ -0,0 +1,252 @@
+[
+    {
+        "id": "a23d2e782beb66f4",
+        "type": "tab",
+        "label": "External Task Sample",
+        "disabled": false,
+        "info": "",
+        "env": []
+    },
+    {
+        "id": "70d7a70e375b162a",
+        "type": "group",
+        "z": "a23d2e782beb66f4",
+        "style": {
+            "stroke": "#999999",
+            "stroke-opacity": "1",
+            "fill": "none",
+            "fill-opacity": "1",
+            "label": true,
+            "label-position": "nw",
+            "color": "#a4a4a4"
+        },
+        "nodes": [
+            "2991a5e6df2b87d2",
+            "911fde53bcbb7e3f",
+            "d56bb7cd73fd220c",
+            "15a5f64b9e2e05fc"
+        ],
+        "x": 34,
+        "y": 79,
+        "w": 512,
+        "h": 142
+    },
+    {
+        "id": "31cb6729aac0ba46",
+        "type": "group",
+        "z": "a23d2e782beb66f4",
+        "style": {
+            "stroke": "#999999",
+            "stroke-opacity": "1",
+            "fill": "none",
+            "fill-opacity": "1",
+            "label": true,
+            "label-position": "nw",
+            "color": "#a4a4a4"
+        },
+        "nodes": [
+            "18e05d562d48f32d",
+            "49aee03a7885fae8",
+            "e4555d9019cd3f47",
+            "bd68c4bdc53b8f80",
+            "fb87f79852b22e4a",
+            "1ba1e62c9935255f",
+            "b49f226ba865e164"
+        ],
+        "x": 34,
+        "y": 259,
+        "w": 812,
+        "h": 202
+    },
+    {
+        "id": "2991a5e6df2b87d2",
+        "type": "externaltask-input",
+        "z": "a23d2e782beb66f4",
+        "g": "70d7a70e375b162a",
+        "name": "Test",
+        "engine": "42e6796dddd9d4db",
+        "topic": "Test",
+        "x": 110,
+        "y": 180,
+        "wires": [
+            [
+                "d56bb7cd73fd220c"
+            ]
+        ]
+    },
+    {
+        "id": "911fde53bcbb7e3f",
+        "type": "externaltask-output",
+        "z": "a23d2e782beb66f4",
+        "g": "70d7a70e375b162a",
+        "name": "Test Ende",
+        "x": 460,
+        "y": 180,
+        "wires": []
+    },
+    {
+        "id": "d56bb7cd73fd220c",
+        "type": "delay",
+        "z": "a23d2e782beb66f4",
+        "g": "70d7a70e375b162a",
+        "name": "",
+        "pauseType": "delay",
+        "timeout": "1",
+        "timeoutUnits": "seconds",
+        "rate": "1",
+        "nbRateUnits": "1",
+        "rateUnits": "second",
+        "randomFirst": "1",
+        "randomLast": "5",
+        "randomUnits": "seconds",
+        "drop": false,
+        "allowrate": false,
+        "outputs": 1,
+        "x": 280,
+        "y": 180,
+        "wires": [
+            [
+                "911fde53bcbb7e3f"
+            ]
+        ]
+    },
+    {
+        "id": "18e05d562d48f32d",
+        "type": "externaltask-input",
+        "z": "a23d2e782beb66f4",
+        "g": "31cb6729aac0ba46",
+        "name": "SampleError",
+        "engine": "42e6796dddd9d4db",
+        "topic": "SampleError",
+        "x": 130,
+        "y": 360,
+        "wires": [
+            [
+                "49aee03a7885fae8"
+            ]
+        ]
+    },
+    {
+        "id": "49aee03a7885fae8",
+        "type": "delay",
+        "z": "a23d2e782beb66f4",
+        "g": "31cb6729aac0ba46",
+        "name": "",
+        "pauseType": "delay",
+        "timeout": "5",
+        "timeoutUnits": "seconds",
+        "rate": "1",
+        "nbRateUnits": "1",
+        "rateUnits": "second",
+        "randomFirst": "1",
+        "randomLast": "5",
+        "randomUnits": "seconds",
+        "drop": false,
+        "allowrate": false,
+        "outputs": 1,
+        "x": 320,
+        "y": 360,
+        "wires": [
+            [
+                "bd68c4bdc53b8f80"
+            ]
+        ]
+    },
+    {
+        "id": "e4555d9019cd3f47",
+        "type": "catch",
+        "z": "a23d2e782beb66f4",
+        "g": "31cb6729aac0ba46",
+        "name": "",
+        "scope": "group",
+        "uncaught": false,
+        "x": 510,
+        "y": 420,
+        "wires": [
+            [
+                "fb87f79852b22e4a"
+            ]
+        ]
+    },
+    {
+        "id": "bd68c4bdc53b8f80",
+        "type": "function",
+        "z": "a23d2e782beb66f4",
+        "g": "31cb6729aac0ba46",
+        "name": "raise Error",
+        "func": "throw Error(\"hello error\");\n\nreturn msg;",
+        "outputs": 1,
+        "timeout": 0,
+        "noerr": 0,
+        "initialize": "",
+        "finalize": "",
+        "libs": [],
+        "x": 510,
+        "y": 360,
+        "wires": [
+            [
+                "1ba1e62c9935255f"
+            ]
+        ]
+    },
+    {
+        "id": "fb87f79852b22e4a",
+        "type": "externaltask-error",
+        "z": "a23d2e782beb66f4",
+        "g": "31cb6729aac0ba46",
+        "name": "Send Error to Engine",
+        "error": "MyErrorCode",
+        "x": 720,
+        "y": 420,
+        "wires": [
+            []
+        ]
+    },
+    {
+        "id": "1ba1e62c9935255f",
+        "type": "externaltask-output",
+        "z": "a23d2e782beb66f4",
+        "g": "31cb6729aac0ba46",
+        "name": "",
+        "x": 710,
+        "y": 360,
+        "wires": []
+    },
+    {
+        "id": "15a5f64b9e2e05fc",
+        "type": "comment",
+        "z": "a23d2e782beb66f4",
+        "g": "70d7a70e375b162a",
+        "name": "Simple External Task handling",
+        "info": "",
+        "x": 180,
+        "y": 120,
+        "wires": []
+    },
+    {
+        "id": "b49f226ba865e164",
+        "type": "comment",
+        "z": "a23d2e782beb66f4",
+        "g": "31cb6729aac0ba46",
+        "name": "Error handling with external tasks",
+        "info": "",
+        "x": 190,
+        "y": 300,
+        "wires": []
+    },
+    {
+        "id": "799125e21de02f13",
+        "type": "comment",
+        "z": "a23d2e782beb66f4",
+        "name": "For Testing, deploy \"External-Task-Sample.bpmn\" and start the process.",
+        "info": "",
+        "x": 300,
+        "y": 40,
+        "wires": []
+    },
+    {
+        "id": "42e6796dddd9d4db",
+        "type": "processcube-engine-config",
+        "url": "http://engine:8000"
+    }
+]

package/externaltask-error.html

@@ -26,6 +26,20 @@
     </div>
 </script>
 
-<script type="text/html" data-help-name="externaltask-error">
-    <p>A node which error response to an External Task of https://processcube.io</p>
+<script type="text/markdown" data-help-name="externaltask-error">
+    Used for reporting errors in the processing of external tasks. The error
+    code `Error` in the configuration is forwarded to the ProcessCube engine for
+    handling within _Error-Boundary-Events_.
+
+    ## Inputs
+
+    : msg (Object) : Passed as `ErrorDetails` to the engine
+    : Error (string) : From the configuration
+    : Message (string) : The caught exception message
+    : StackTrace (string) : The stack trace of the exception
+
+    ### 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-error.js

@@ -7,24 +7,22 @@ module.exports = function (RED) {
         var eventEmitter = flowContext.get('emitter');
 
         node.on('input', function (msg) {
-            const externalTaskId = msg.externalTaskId;
+            const flowNodeInstanceId = msg.flowNodeInstanceId;
 
-            let error = msg.error;
+            let msgError = msg.error;
 
-            if (error === undefined) {
-                error.message = 'An error occurred';
-                error.source = msg.payload;
+            if (msgError === undefined) {
+                msgError.message = 'An error occurred';
             }
 
-            msg.payload = {
-                error: {
-                    errorCode: config.error,
-                    errorMessage: error.message,
-                    errorDetails: error.source,
-                },
-            };
+            const error = new Error(msgError.message);
+            error.errorCode = config.error;
+            error.errorDetails = RED.util.encodeObject(msg);
 
-            eventEmitter.emit(`error-${externalTaskId}`, msg.payload);
+            msg.errorCode = config.error;
+            msg.errorMessage = msgError.message;
+
+            eventEmitter.emit(`handle-${flowNodeInstanceId}`, error, true);
 
             node.send(msg);
         });

package/externaltask-input.html

@@ -31,6 +31,23 @@
     </div>
 </script>
 
-<script type="text/html" data-help-name="externaltask-input">
-    <p>A node which subscribes to an External Task Topic of https://processcube.io</p>
+<script type="text/markdown" data-help-name="externaltask-input">
+    Waiting for external tasks that correspond to the `Topic` configured in
+    the connected ProcessCube Engine for processing.
+
+    ## Outputs
+
+    : payload (string) : Defines the input of the external task token
+    : task (object) : The external task object
+    : flowNodeInstanceId : The Id of the external task, which is needed to complete the task
+
+    ### Details
+
+    -   To finish the external task the `externaltask-output` node is required.
+    -   For handling a error while executing a flow as external task the `externaltask-error` node is required.
+
+    ### References
+
+    -   [The ProcessCube Developer Network](https://processcube.io) - All documentation for the ProcessCube&copy; Plattform
+    -   [Node-RED Integration in ProcessCube&copy;](https://processcube.io/docs/node-red) - Node-RED Integration in ProcessCube&copy;
 </script>

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) {
     function ExternalTaskInput(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');
 
@@ -49,33 +29,78 @@ module.exports = function (RED) {
 
         client.externalTasks
             .subscribeToExternalTaskTopic(config.topic, async (payload, externalTask) => {
-                msgCounter++;
+                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,
+                    };
 
-                    showStatus(node, msgCounter);
+                    node.log(
+                        `Received *external task flowNodeInstanceId* '${externalTask.flowNodeInstanceId}' and *processInstanceId* '${externalTask.processInstanceId}' with *msg._msgid* '${msg._msgid}'`,
+                    );
 
-                    node.send({
-                        topic: externalTask.topic,
-                        payload: payload,
-                        externalTaskId: externalTask.flowNodeInstanceId,
-                    });
+                    node.send(msg);
                 });
             })
             .then(async (externalTaskWorker) => {
@@ -85,16 +110,47 @@ module.exports = function (RED) {
                 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);
 };

package/externaltask-output.html

@@ -21,6 +21,16 @@
     </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 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

@@ -7,13 +7,13 @@ module.exports = function (RED) {
         var eventEmitter = flowContext.get('emitter');
 
         node.on('input', function (msg) {
-            const externalTaskId = msg.externalTaskId;
+            const flowNodeInstanceId = msg.flowNodeInstanceId;
 
-            if (!externalTaskId) {
+            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);

package/message-event-trigger.js

@@ -6,18 +6,10 @@ 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');
-        }
+        const client = this.engine.getEngineClient();
 
         node.on('input', function (msg) {
             client.events
@@ -30,7 +22,11 @@ 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);