@5minds/node-red-contrib-processcube 1.16.1 → 1.16.2

package/externaltask-input.js

@@ -1,9 +1,110 @@
 const EventEmitter = require('node:events');
 
+class ExternalTaskNodeStates {
+    constructor(flowNodeInstanceId) {
+        this.flowNodeInstanceId = flowNodeInstanceId;
+        this.nodeStades = {}; // Track send calls per nodeId
+    }
+
+    markSended(nodeId) {
+        if (!this.nodeStades[nodeId]) {
+            this.nodeStades[nodeId] = { gotSend: false, gotCompleted: false };
+        }
+
+        this.nodeStades[nodeId].gotSend = true;
+    }
+
+    markCompleted(nodeId) {
+        if (!this.nodeStades[nodeId]) {
+            this.nodeStades[nodeId] = { gotSend: false, gotCompleted: false };
+        }
+
+        this.nodeStades[nodeId].gotCompleted = true;
+    }
+
+    checkIfCompletedWithoutSend(nodeId) {
+        const nodeState = this.nodeStades[nodeId];
+        const result = (nodeState && nodeState.gotCompleted && !nodeState.gotSend);
+
+        return result;
+    }
+}
+
 module.exports = function (RED) {
 
     const os = require('os');
 
+    // Global dictionary for tracking external tasks by flowNodeInstanceId
+    const globalExternalTaskStates = {};
+    
+    const raiseExternalTaskError = (flowNodeInstanceId, etwInputNodeId, nodeId) => {
+        const fullNode = RED.nodes.getNode(nodeId);
+
+        const wires = fullNode?.wires;
+        const hasConnectedOutputs = wires && wires.some(wireArray => wireArray && wireArray.length > 0);
+
+        if (hasConnectedOutputs) {
+            const inputNode = RED.nodes.getNode(etwInputNodeId);
+
+            if (inputNode && inputNode.eventEmitter) {
+                const errorMessage = `Node ${nodeId} (${fullNode.name || fullNode.type}) completed without sending output`;
+                const error = new Error(errorMessage);
+                error.errorCode = 'NODE_NO_OUTPUT';
+                error.errorDetails = RED.util.encodeObject({
+                    flowNodeInstanceId: flowNodeInstanceId,
+                    nodeId: nodeId,
+                    nodeName: fullNode.name,
+                    nodeType: fullNode.type
+                });
+
+                inputNode.eventEmitter.emit(`handle-${flowNodeInstanceId}`, error, true);
+            }
+        }
+    };
+
+    // Example synchronous onSend hook
+    RED.hooks.add("onSend", (sendEvents) => {
+        for (const sendEvent of sendEvents) {
+
+             // Call send method on ExternalTaskState if this message has a flowNodeInstanceId
+             if (sendEvent.msg?.flowNodeInstanceId) {
+                let externalTaskNodeStates = globalExternalTaskStates[sendEvent.msg.flowNodeInstanceId];
+
+                if (!externalTaskNodeStates) {
+                    externalTaskNodeStates = new ExternalTaskNodeStates(sendEvent.msg.flowNodeInstanceId);
+                    globalExternalTaskStates[sendEvent.msg.flowNodeInstanceId] = externalTaskNodeStates;
+                }
+
+                externalTaskNodeStates.markSended(sendEvent.source.node.id)
+
+                if (externalTaskNodeStates.checkIfCompletedWithoutSend(sendEvent.source.node.id)) {
+                    raiseExternalTaskError(sendEvent.msg.flowNodeInstanceId, sendEvent.msg.etw_input_node_id, sendEvent.source.node.id);
+                }
+             }
+        }
+    });
+
+    const onCompleted = (completeEvent) => {
+
+        // Check if this is an external task message
+        if (completeEvent.msg?.flowNodeInstanceId) {
+            let externalTaskNodeStates = globalExternalTaskStates[completeEvent.msg.flowNodeInstanceId];
+
+            if (!externalTaskNodeStates) {
+                externalTaskNodeStates = new ExternalTaskNodeStates(completeEvent.msg.flowNodeInstanceId);
+                globalExternalTaskStates[completeEvent.msg.flowNodeInstanceId] = externalTaskNodeStates;
+            }
+
+            externalTaskNodeStates.markCompleted(completeEvent.node.id);
+
+            if (externalTaskNodeStates.checkIfCompletedWithoutSend(completeEvent.node.id)) {
+                raiseExternalTaskError(completeEvent.msg.flowNodeInstanceId, completeEvent.msg.etw_input_node_id, completeEvent.node.id);
+            }
+        }
+    }
+
+    RED.hooks.add("onComplete", onCompleted);
+
     function ExternalTaskInput(config) {
         RED.nodes.createNode(this, config);
         var node = this;
@@ -165,60 +266,68 @@ module.exports = function (RED) {
         };
 
         const onPreDeliver = (sendEvent) => {
-            if (node.isHandling() && node.ownMessage(sendEvent.msg)) {  
-                
-                const sourceNode = sendEvent?.source?.node;
-                const destinationNode = sendEvent?.destination?.node;
+            try {
+                if (node.isHandling() && node.ownMessage(sendEvent.msg)) {
 
-                node._step = `${destinationNode.name || destinationNode.type}`;
+                    const sourceNode = sendEvent?.source?.node;
+                    const destinationNode = sendEvent?.destination?.node;
 
-                node.showStatus();
+                    node._step = `${destinationNode.name || destinationNode.type}`;
 
-                const debugMsg = {
-                    event: 'enter',
-                    sourceName: sourceNode.name,
-                    sourceType: sourceNode.type,
-                    destinationNodeName: destinationNode.name,
-                    destinationNodeType: destinationNode.type,
-                    timestamp: new Date().toISOString(),
-                };
+                    node.showStatus();
+
+                    const debugMsg = {
+                        event: 'enter',
+                        sourceName: sourceNode.name,
+                        sourceType: sourceNode.type,
+                        destinationNodeName: destinationNode.name,
+                        destinationNodeType: destinationNode.type,
+                        timestamp: new Date().toISOString(),
+                    };
 
-                node.traceExecution(debugMsg);
+                    node.traceExecution(debugMsg);
 
-                if (process.env.NODE_RED_ETW_STEP_LOGGING == 'true' || process.env.NODERED_ETW_STEP_LOGGING == 'true') {
-                    node._trace = `'${sourceNode.name || sourceNode.type}'->'${destinationNode.name || destinationNode.type}'`;
-                    node.log(`preDeliver: ${node._trace}`);
+                    if (process.env.NODE_RED_ETW_STEP_LOGGING == 'true' || process.env.NODERED_ETW_STEP_LOGGING == 'true') {
+                        node._trace = `'${sourceNode.name || sourceNode.type}'->'${destinationNode.name || destinationNode.type}'`;
+                        node.log(`preDeliver: ${node._trace}`);
+                    }
                 }
+            } catch (error) {
+                node.error(`Error in onPreDeliver: ${error?.message}`, { error: error });
             }
         };
-        RED.hooks.add('preDeliver', onPreDeliver);
+        RED.hooks.add(`preDeliver.etw-input-${node.id}`, onPreDeliver);
 
         const onPostDeliver = (sendEvent) => {
-            if (node.isHandling() && node.ownMessage(sendEvent.msg)) {
-                const sourceNode = sendEvent?.source?.node;
-                const destinationNode = sendEvent?.destination?.node;
-
-                node.decrMsgOnNode(sourceNode, sendEvent.msg);
-                node.incMsgOnNode(destinationNode, sendEvent.msg);
-
-                const debugMsg = {
-                    event: 'exit',
-                    sourceName: sourceNode.name,
-                    sourceType: sourceNode.type,
-                    destinationNodeName: destinationNode.name,
-                    destinationNodeType: destinationNode.type,
-                    timestamp: new Date().toISOString(),
-                };
+            try {
+                if (node.isHandling() && node.ownMessage(sendEvent.msg)) {
+                    const sourceNode = sendEvent?.source?.node;
+                    const destinationNode = sendEvent?.destination?.node;
+
+                    node.decrMsgOnNode(sourceNode, sendEvent.msg);
+                    node.incMsgOnNode(destinationNode, sendEvent.msg);
+
+                    const debugMsg = {
+                        event: 'exit',
+                        sourceName: sourceNode.name,
+                        sourceType: sourceNode.type,
+                        destinationNodeName: destinationNode.name,
+                        destinationNodeType: destinationNode.type,
+                        timestamp: new Date().toISOString(),
+                    };
 
-                node.traceExecution(debugMsg);
+                    node.traceExecution(debugMsg);
 
-                if (process.env.NODE_RED_ETW_STEP_LOGGING == 'true' || process.env.NODERED_ETW_STEP_LOGGING == 'true') {
-                    node._trace = `'${sourceNode.name || sourceNode.type}'->'${destinationNode.name || destinationNode.type}'`;
-                    node.log(`postDeliver: ${node._trace}`);
+                    if (process.env.NODE_RED_ETW_STEP_LOGGING == 'true' || process.env.NODERED_ETW_STEP_LOGGING == 'true') {
+                        node._trace = `'${sourceNode.name || sourceNode.type}'->'${destinationNode.name || destinationNode.type}'`;
+                        node.log(`postDeliver: ${node._trace}`);
+                    }
                 }
+            } catch (error) {
+                node.error(`Error in onPostDeliver: ${error?.message}`, { error: error });
             }
         };
-        RED.hooks.add('postDeliver', onPostDeliver);
+        RED.hooks.add(`postDeliver.etw-input-${node.id}`, onPostDeliver);
 
         node.setSubscribedStatus = () => {
             this._subscribed = true;
@@ -349,15 +458,30 @@ module.exports = function (RED) {
                 return;
             }
             const etwCallback = async (payload, externalTask) => {
+
+                globalExternalTaskStates[externalTask.flowNodeInstanceId] = new ExternalTaskNodeStates(externalTask.flowNodeInstanceId);
+
                 const saveHandleCallback = (data, callback, msg) => {
                     try {
                         callback(data);
                         node.log(`send to engine *external task flowNodeInstanceId* '${externalTask.flowNodeInstanceId}', topic '${node.topic}' and *processInstanceId* ${externalTask.processInstanceId}`);
+
+                        // Remove ExternalTaskState from global dictionary
+                        if (globalExternalTaskStates[externalTask.flowNodeInstanceId]) {
+                            delete globalExternalTaskStates[externalTask.flowNodeInstanceId];
+                        }
+
                         node.setFinishHandlingTaskStatus(externalTask);
                     } catch (error) {
+                        // Remove ExternalTaskState from global dictionary on error as well
+                        if (globalExternalTaskStates[externalTask.flowNodeInstanceId]) {
+                            delete globalExternalTaskStates[externalTask.flowNodeInstanceId];
+                        }
+
                         node.setErrorFinishHandlingTaskStatus(externalTask, error);
                         msg.error = error;
                         node.error(`failed send to engine *external task flowNodeInstanceId* '${externalTask.flowNodeInstanceId}', topic '${node.topic}' and *processInstanceId* ${externalTask.processInstanceId}: ${error?.message}`, msg);
+                        callback(error);
                     }
                 };
 
@@ -397,7 +521,7 @@ module.exports = function (RED) {
                                 msg.etw_duration = new Date(msg.etw_finished_at) - new Date(msg.etw_started_at);
                             }
                         } catch (error) {
-                            node.error(`failed to calculate duration: ${error?.message}`, msg);   
+                            node.error(`failed to calculate duration: ${error?.message}`, msg);
                         }
 
                         node.log(
@@ -488,12 +612,12 @@ module.exports = function (RED) {
 
                     node.on('close', () => {
                         try {
-                            RED.hooks.remove('preDeliver', onPreDeliver);
-                            RED.hooks.remove('postDeliver', onPostDeliver);
                             externalTaskWorker.stop();
+                            RED.hooks.remove(`preDeliver.etw-input-${node.id}`);
+                            RED.hooks.remove(`postDeliver.etw-input-${node.id}`);
                             node.log('External Task Worker closed.');
-                        } catch {
-                            node.error('Client close failed', {});
+                        } catch (error) {
+                            node.error(`Client close failed: ${JSON.stringify(error)}`);
                         }
                     });
                 })

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@5minds/node-red-contrib-processcube",
-    "version": "1.16.1",
+    "version": "1.16.2",
     "license": "MIT",
     "description": "Node-RED nodes for ProcessCube",
     "scripts": {