@blokcert/node-red-contrib-ocpp 1.0.2 → 1.1.1

package/CHANGELOG.md

@@ -0,0 +1,46 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+## [1.1.1] - 2026-02-12
+
+### Fixed
+- Fixed `ocpp-response` node to correctly find and notify `ocpp-command` nodes using `RED.nodes.getNode()` instead of `RED.nodes.eachNode()`
+
+## [1.1.0] - 2026-02-12
+
+### Added
+- **New `ocpp-response` node** - Routes CALLRESULT/CALLERROR responses back to the originating ocpp-command nodes
+- Response message support in `ocpp-in` node with `messageType` and `ocppMessageType` fields
+- New filter options in `ocpp-in`:
+  - `_CallResult` - Filter for only CALLRESULT responses
+  - `_CallError` - Filter for only CALLERROR responses
+  - `_Response` - Filter for both response types
+
+### Fixed
+- Fixed parsing of CALLRESULT/CALLERROR messages (previously showed as "[Unknown]")
+- Response messages now correctly set `action` to `_CallResult` or `_CallError` for routing
+
+### Changed
+- `ocpp-in` status now shows descriptive text for response messages (e.g., "Response abc123 from test:charger001")
+
+## [1.0.2] - 2026-02-10
+
+### Fixed
+- Minor bug fixes
+
+## [1.0.1] - 2026-02-08
+
+### Fixed
+- Initial bug fixes after release
+
+## [1.0.0] - 2026-02-05
+
+### Added
+- Initial release
+- `ocpp-in` node for receiving OCPP messages via Redis Streams
+- `ocpp-out` node for sending OCPP responses
+- `ocpp-command` node for sending CSMS-initiated commands
+- `ocpp-config` node for Redis connection configuration
+- OCPP 1.6 and 2.0.1 support with automatic normalization/denormalization
+- Consumer group support for horizontal scaling

package/README.md

@@ -34,16 +34,25 @@ Receives OCPP messages from charging stations via Redis Streams.
 **Features:**
 - Consumer group support for load balancing
 - Optional payload normalization (OCPP 1.6/2.0.1 → unified format)
-- Filter by action type
+- Filter by action type or response type
 - Auto-acknowledge messages
 
+**Filter Options:**
+- Empty: Receive all messages (CALL requests + responses)
+- Action name (e.g., `BootNotification`): Only CALL requests with this action
+- `_CallResult`: Only CALLRESULT responses
+- `_CallError`: Only CALLERROR responses
+- `_Response`: Both CALLRESULT and CALLERROR responses
+
 **Output:**
 ```javascript
 {
   payload: { /* OCPP message payload */ },
   ocpp: {
     messageId: "abc123",
-    action: "BootNotification",
+    action: "BootNotification",  // or "_CallResult" / "_CallError" for responses
+    messageType: "call",         // "call", "result", or "error"
+    ocppMessageType: 2,          // 2=CALL, 3=CALLRESULT, 4=CALLERROR
     version: "1.6",
     tenant: "operator1",
     deviceId: "charger001",
@@ -94,6 +103,10 @@ Sends CSMS-initiated commands to charging stations.
 - ClearCache
 - And more...
 
+**Outputs:**
+- Output 1: Command sent confirmation
+- Output 2: Device response or timeout error (when "Wait for Response" is enabled)
+
 **Example:**
 ```javascript
 msg.ocpp = {
@@ -107,6 +120,37 @@ msg.payload = {
 return msg;
 ```
 
+### ocpp response
+
+Routes CALLRESULT/CALLERROR responses back to the originating ocpp-command nodes.
+
+**Features:**
+- Automatically matches responses to pending commands
+- Notifies ocpp-command nodes of responses
+- Calculates round-trip latency
+
+**Setup:**
+Connect this node to an `ocpp in` node (optionally filtered by `_Response`) to receive device responses:
+
+```
+[ocpp in (filter: _Response)] → [ocpp response] → [debug]
+```
+
+**Output:**
+```javascript
+{
+  payload: { /* device response */ },
+  ocpp: {
+    messageId: "abc123",
+    action: "GetConfiguration",  // Original command
+    response: true,
+    error: false,
+    latency: 150,  // Round-trip time in ms
+    handled: true  // Whether an ocpp-command node was notified
+  }
+}
+```
+
 ## Example Flow
 
 ```

package/lib/ocpp-normalizer.js

@@ -22,7 +22,7 @@ const MessageType = {
 function parseStreamMessage(streamData) {
     const { tenant, deviceId, timestamp } = streamData;
 
-    // Parse metadata (contains action, version, serverID)
+    // Parse metadata (contains action, version, serverID, type)
     let metadata = {};
     if (streamData.metadata) {
         try {
@@ -47,8 +47,21 @@ function parseStreamMessage(streamData) {
     // Extract messageId from payload.uniqueID or streamData.id
     const messageId = parsedPayload?.uniqueID || streamData.id;
 
-    // Extract action from metadata or payload
-    const action = metadata.action || parsedPayload?.action;
+    // Determine message type from metadata (call, result, error)
+    // messageType in payload contains the OCPP numeric type (2=CALL, 3=CALLRESULT, 4=CALLERROR)
+    const msgType = metadata.type || 'call';
+    const ocppMessageType = parsedPayload?.messageType || MessageType.CALL;
+
+    // Extract action from metadata or payload (only for CALL messages)
+    let action = metadata.action || parsedPayload?.action;
+
+    // For result/error messages, action is not present in the message
+    // We mark them with special action names for routing
+    if (msgType === 'result' || ocppMessageType === MessageType.CALLRESULT) {
+        action = action || '_CallResult';
+    } else if (msgType === 'error' || ocppMessageType === MessageType.CALLERROR) {
+        action = action || '_CallError';
+    }
 
     // Extract actual payload content
     const actualPayload = parsedPayload?.payload || parsedPayload;
@@ -62,6 +75,8 @@ function parseStreamMessage(streamData) {
         tenant,
         deviceId,
         action,
+        messageType: msgType,           // 'call', 'result', or 'error'
+        ocppMessageType,                // 2, 3, or 4
         payload: actualPayload,
         version,
         protocol,

package/nodes/ocpp-in.html

@@ -72,7 +72,9 @@
         <dd>OCPP message metadata:
             <ul>
                 <li><code>messageId</code> - Unique message ID</li>
-                <li><code>action</code> - OCPP action (e.g., BootNotification, Heartbeat)</li>
+                <li><code>action</code> - OCPP action (e.g., BootNotification) or <code>_CallResult</code>/<code>_CallError</code> for responses</li>
+                <li><code>messageType</code> - "call", "result", or "error"</li>
+                <li><code>ocppMessageType</code> - Numeric OCPP message type (2=CALL, 3=CALLRESULT, 4=CALLERROR)</li>
                 <li><code>version</code> - OCPP version (1.6 or 2.0.1)</li>
                 <li><code>tenant</code> - Operator/tenant identifier</li>
                 <li><code>deviceId</code> - Charger/station ID</li>
@@ -104,16 +106,26 @@
         This allows your flow to handle both versions with the same logic.</dd>
 
         <dt>Filter Action <span class="property-type">string</span></dt>
-        <dd>Optional. Only output messages with this action name.
-        Leave empty to receive all actions.</dd>
+        <dd>Optional. Only output messages matching this filter.
+        Leave empty to receive all messages.</dd>
     </dl>
 
     <h3>Details</h3>
     <p>This node reads from the <code>ws:inbound</code> Redis Stream using consumer groups,
     allowing multiple Node-RED instances to share the message load.</p>
 
-    <h3>Supported Actions</h3>
-    <p>Common OCPP actions that can be filtered:</p>
+    <h3>Filter Options</h3>
+    <p>The Filter Action field supports these values:</p>
+    <ul>
+        <li><strong>Empty</strong> - Receive all messages (CALL requests + responses)</li>
+        <li><strong>Action name</strong> (e.g., <code>BootNotification</code>) - Only receive CALL requests with this action</li>
+        <li><code>_CallResult</code> - Only receive CALLRESULT responses</li>
+        <li><code>_CallError</code> - Only receive CALLERROR responses</li>
+        <li><code>_Response</code> - Receive both CALLRESULT and CALLERROR responses</li>
+    </ul>
+
+    <h3>Common OCPP Actions</h3>
+    <p>Actions that can be filtered:</p>
     <ul>
         <li><code>BootNotification</code></li>
         <li><code>Heartbeat</code></li>

package/nodes/ocpp-in.js

@@ -112,12 +112,35 @@ module.exports = function (RED) {
                 msg.streamId = streamId;
 
                 // Apply action filter if configured
-                if (node.filterAction && msg.action !== node.filterAction) {
-                    // Auto-ack filtered messages if autoAck is enabled
-                    if (node.autoAck) {
-                        await redis.xack(streamKey, consumerGroup, streamId);
+                // Special filter values:
+                //   - "_CallResult" - only CALLRESULT responses
+                //   - "_CallError" - only CALLERROR responses
+                //   - "_Response" - both CALLRESULT and CALLERROR
+                //   - Any other value filters CALL messages by action name
+                if (node.filterAction) {
+                    const filter = node.filterAction;
+                    const isResult = msg.messageType === 'result';
+                    const isError = msg.messageType === 'error';
+
+                    let shouldPass = false;
+                    if (filter === '_CallResult') {
+                        shouldPass = isResult;
+                    } else if (filter === '_CallError') {
+                        shouldPass = isError;
+                    } else if (filter === '_Response') {
+                        shouldPass = isResult || isError;
+                    } else {
+                        // Filter CALL messages by action, pass through responses
+                        shouldPass = msg.action === filter;
+                    }
+
+                    if (!shouldPass) {
+                        // Auto-ack filtered messages if autoAck is enabled
+                        if (node.autoAck) {
+                            await redis.xack(streamKey, consumerGroup, streamId);
+                        }
+                        return;
                     }
-                    return;
                 }
 
                 // Normalize payload if enabled
@@ -131,6 +154,8 @@ module.exports = function (RED) {
                     ocpp: {
                         messageId: msg.messageId,
                         action: msg.action,
+                        messageType: msg.messageType,        // 'call', 'result', or 'error'
+                        ocppMessageType: msg.ocppMessageType, // 2, 3, or 4
                         version: msg.version,
                         protocol: msg.protocol,
                         tenant: msg.tenant,
@@ -143,11 +168,19 @@ module.exports = function (RED) {
                     _msgid: RED.util.generateId(),
                 };
 
-                // Update status
+                // Update status - show different text for call vs result/error
+                let statusText;
+                if (msg.messageType === 'result') {
+                    statusText = `Response ${msg.messageId?.slice(0, 8)} from ${msg.identity}`;
+                } else if (msg.messageType === 'error') {
+                    statusText = `Error ${msg.messageId?.slice(0, 8)} from ${msg.identity}`;
+                } else {
+                    statusText = `${msg.action} from ${msg.identity}`;
+                }
                 node.status({
                     fill: 'green',
                     shape: 'dot',
-                    text: `${msg.action} from ${msg.identity}`,
+                    text: statusText,
                 });
 
                 // Send to output

package/nodes/ocpp-response.html

@@ -0,0 +1,98 @@
+<script type="text/javascript">
+    RED.nodes.registerType('ocpp-response', {
+        category: 'OCPP',
+        color: '#89D689',
+        defaults: {
+            name: { value: '' },
+            server: { value: '', type: 'ocpp-config', required: true },
+        },
+        inputs: 1,
+        outputs: 1,
+        icon: 'font-awesome/fa-reply',
+        label: function () {
+            return this.name || 'ocpp response';
+        },
+        paletteLabel: 'ocpp response',
+    });
+</script>
+
+<script type="text/html" data-template-name="ocpp-response">
+    <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">
+    </div>
+    <div class="form-row">
+        <label for="node-input-server"><i class="fa fa-server"></i> Server</label>
+        <input type="text" id="node-input-server">
+    </div>
+</script>
+
+<script type="text/html" data-help-name="ocpp-response">
+    <p>Routes CALLRESULT/CALLERROR responses back to the originating ocpp-command nodes.</p>
+
+    <h3>Overview</h3>
+    <p>When you send a command to a charging station using <code>ocpp-command</code>,
+    the station will respond with a CALLRESULT (success) or CALLERROR (failure).</p>
+    <p>This node routes those responses back to the correct <code>ocpp-command</code> node
+    that originated the request.</p>
+
+    <h3>Setup</h3>
+    <p>Connect this node to an <code>ocpp-in</code> node. When a response message arrives,
+    this node will:</p>
+    <ol>
+        <li>Check if it's a CALLRESULT or CALLERROR message</li>
+        <li>Look up the pending command in Redis</li>
+        <li>Find and notify the originating <code>ocpp-command</code> node</li>
+        <li>Pass through the response for additional processing</li>
+    </ol>
+
+    <h3>Inputs</h3>
+    <dl class="message-properties">
+        <dt>payload <span class="property-type">object</span></dt>
+        <dd>The response payload from the charging station.</dd>
+
+        <dt>ocpp.messageId <span class="property-type">string</span></dt>
+        <dd>The unique message ID matching the original command.</dd>
+
+        <dt>ocpp.messageType <span class="property-type">string</span></dt>
+        <dd>"result" for CALLRESULT, "error" for CALLERROR.</dd>
+    </dl>
+
+    <h3>Outputs</h3>
+    <dl class="message-properties">
+        <dt>payload <span class="property-type">object</span></dt>
+        <dd>The response payload (unchanged).</dd>
+
+        <dt>ocpp.action <span class="property-type">string</span></dt>
+        <dd>The original command action (e.g., "GetConfiguration").</dd>
+
+        <dt>ocpp.response <span class="property-type">boolean</span></dt>
+        <dd>Always true for responses.</dd>
+
+        <dt>ocpp.error <span class="property-type">boolean</span></dt>
+        <dd>True if this was a CALLERROR response.</dd>
+
+        <dt>ocpp.handled <span class="property-type">boolean</span></dt>
+        <dd>True if an ocpp-command node was found and notified.</dd>
+
+        <dt>ocpp.latency <span class="property-type">number</span></dt>
+        <dd>Round-trip time in milliseconds.</dd>
+    </dl>
+
+    <h3>Typical Flow</h3>
+    <pre>
+[inject] → [ocpp-command] → (sent to device)
+                          ↘ [debug: command sent]
+
+[ocpp-in] → [ocpp-response] → [debug: response received]
+              ↓
+        (notifies ocpp-command)
+              ↓
+[ocpp-command second output] → [debug: command response]
+    </pre>
+
+    <h3>References</h3>
+    <ul>
+        <li><a href="https://www.openchargealliance.org/">Open Charge Alliance</a></li>
+    </ul>
+</script>

package/nodes/ocpp-response.js

@@ -0,0 +1,177 @@
+/**
+ * OCPP Response Router Node
+ * Routes CALLRESULT/CALLERROR responses back to the originating ocpp-command nodes
+ *
+ * Connect this node's input to an ocpp-in node that receives response messages.
+ * It will automatically find and notify the corresponding ocpp-command node.
+ */
+const { Keys } = require('../lib/redis-client');
+const { MessageType } = require('../lib/ocpp-normalizer');
+
+module.exports = function (RED) {
+    function OCPPResponseNode(config) {
+        RED.nodes.createNode(this, config);
+        const node = this;
+
+        // Get config node
+        node.server = RED.nodes.getNode(config.server);
+        if (!node.server) {
+            node.error('No OCPP config node configured');
+            node.status({ fill: 'red', shape: 'ring', text: 'no config' });
+            return;
+        }
+
+        const redis = node.server.redis;
+
+        /**
+         * Handle incoming response messages from ocpp-in
+         */
+        node.on('input', async (msg, send, done) => {
+            try {
+                const ocpp = msg.ocpp || {};
+                const messageId = ocpp.messageId;
+                const tenant = ocpp.tenant;
+                const deviceId = ocpp.deviceId;
+                const messageType = ocpp.messageType;       // 'call', 'result', 'error'
+                const ocppMessageType = ocpp.ocppMessageType; // 2, 3, 4
+
+                // Only process result and error messages
+                const isResult = messageType === 'result' || ocppMessageType === MessageType.CALLRESULT;
+                const isError = messageType === 'error' || ocppMessageType === MessageType.CALLERROR;
+
+                if (!isResult && !isError) {
+                    // Not a response message, pass through
+                    if (send) send(msg);
+                    if (done) done();
+                    return;
+                }
+
+                if (!messageId || !tenant || !deviceId) {
+                    throw new Error('Missing messageId, tenant, or deviceId in response');
+                }
+
+                // Look up the pending command in Redis
+                const pendingKey = Keys.pending(tenant, deviceId);
+                const pendingData = await redis.hget(pendingKey, messageId);
+
+                if (!pendingData) {
+                    // No pending command found - might have timed out or been handled elsewhere
+                    node.log(`No pending command found for ${messageId}`);
+                    node.status({
+                        fill: 'yellow',
+                        shape: 'ring',
+                        text: `orphan: ${messageId.slice(0, 8)}`,
+                    });
+                    // Still pass through the message
+                    if (send) send(msg);
+                    if (done) done();
+                    return;
+                }
+
+                // Parse pending command data
+                let pendingInfo;
+                try {
+                    pendingInfo = JSON.parse(pendingData);
+                } catch (e) {
+                    pendingInfo = {};
+                }
+
+                // Remove from pending
+                await redis.hdel(pendingKey, messageId);
+
+                // Find and notify all ocpp-command nodes
+                let handled = false;
+
+                // Get all flows and find ocpp-command nodes
+                const allNodes = [];
+                RED.nodes.eachNode((n) => {
+                    if (n.type === 'ocpp-command') {
+                        allNodes.push(n.id);
+                    }
+                });
+
+                // Try to get the runtime node instance and call handleResponse
+                for (const nodeId of allNodes) {
+                    try {
+                        const commandNode = RED.nodes.getNode(nodeId);
+                        if (commandNode && typeof commandNode.handleResponse === 'function') {
+                            const wasHandled = commandNode.handleResponse(messageId, msg.payload, isError);
+                            if (wasHandled) {
+                                handled = true;
+                                node.log(`Response ${messageId} handled by ocpp-command node ${nodeId}`);
+                                break; // Only one node should handle each response
+                            }
+                        }
+                    } catch (e) {
+                        node.warn(`Error calling handleResponse on node ${nodeId}: ${e.message}`);
+                    }
+                }
+
+                // Update status
+                if (handled) {
+                    node.status({
+                        fill: isError ? 'red' : 'green',
+                        shape: 'dot',
+                        text: `${pendingInfo.action || 'response'}: ${isError ? 'error' : 'ok'}`,
+                    });
+                } else {
+                    // No ocpp-command node claimed this response
+                    // This could happen if the node was restarted or if using a different flow pattern
+                    node.status({
+                        fill: 'yellow',
+                        shape: 'ring',
+                        text: `unhandled: ${messageId.slice(0, 8)}`,
+                    });
+                }
+
+                // Build output message with response info
+                const outMsg = {
+                    ...msg,
+                    ocpp: {
+                        ...ocpp,
+                        action: pendingInfo.action,
+                        response: true,
+                        error: isError,
+                        handled,
+                        sentAt: pendingInfo.sentAt,
+                        receivedAt: Date.now(),
+                        latency: pendingInfo.sentAt ? Date.now() - pendingInfo.sentAt : undefined,
+                    },
+                };
+
+                // Pass through the response (for additional processing or logging)
+                if (send) {
+                    send(outMsg);
+                }
+
+                if (done) {
+                    done();
+                }
+
+            } catch (err) {
+                node.error(`Response routing error: ${err.message}`, msg);
+                node.status({ fill: 'red', shape: 'dot', text: err.message });
+
+                if (done) {
+                    done(err);
+                }
+            }
+        });
+
+        // Initial status
+        node.status({ fill: 'grey', shape: 'ring', text: 'ready' });
+
+        // Update status when Redis is ready
+        if (redis) {
+            redis.once('ready', () => {
+                node.status({ fill: 'green', shape: 'ring', text: 'connected' });
+            });
+
+            if (redis.status === 'ready') {
+                node.status({ fill: 'green', shape: 'ring', text: 'connected' });
+            }
+        }
+    }
+
+    RED.nodes.registerType('ocpp-response', OCPPResponseNode);
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@blokcert/node-red-contrib-ocpp",
-  "version": "1.0.2",
+  "version": "1.1.1",
   "description": "Node-RED nodes for OCPP (Open Charge Point Protocol) message handling via Redis Streams",
   "keywords": [
     "node-red",
@@ -22,6 +22,7 @@
       "ocpp-in": "nodes/ocpp-in.js",
       "ocpp-out": "nodes/ocpp-out.js",
       "ocpp-command": "nodes/ocpp-command.js",
+      "ocpp-response": "nodes/ocpp-response.js",
       "ocpp-config": "nodes/ocpp-config.js"
     }
   },