@ralphwetzel/node-red-context-monitor 1.0.0 → 1.1.0

package/README.md

@@ -11,7 +11,14 @@ This node allows to setup the reference to a context, then sends a message when
 
 It sends a dedicated message on a separate port in case it detects that the value of the context was changed.
 
-The message sent will carry the current value of the context as `msg.payload`. Monitoring details will be provided as `msg.monitoring`.
+The message sent will carry the current value of the context as `msg.payload`, the context key as `msg.topic`.
+
+Monitoring details will be provided as `msg.monitoring`:
+* The monitoring setup: `scope` & `key` always, `flow` (id) / `node` (id) if applicable.
+* The id of the node that wrote to the context as `source`.
+
+The message sent off the change port carries an additional property in `msg.monitoring`:
+* The value overwritten as `previous`.
 
 It is possible to monitor an infinite number of contexts with each instance of this node.
 
@@ -38,4 +45,38 @@ To monitor a `Node` scope context, set the scope to `Node`, then select flow & n
 <img alt="node" src="https://raw.githubusercontent.com/ralphwetzel/node-red-context-monitor/main/resources/node.png"
     style="min-width: 474px; width: 474px; align: center; border: 1px solid lightgray;"/>
 
-> Hint: This node doesn't create a context. It just tries to reference to those already existing. If you're referencing a non-existing context, no harm will happen.
+> Hint: This node doesn't create a context. It just tries to reference to those already existing. If you're referencing a non-existing context, no harm will happen.
+
+### Monitoring objects stored in context
+You may of course define a setup that monitors objects stored in context.
+
+If you create a reference to this object (stored in context) and write to its properties, this node issues its messages accordingly.
+
+> Disclaimer: Monitoring changes to elements of an `Array` currently is not supported.
+
+#### Example:
+Monitoring context definition:
+
+<img alt="flow" src="https://raw.githubusercontent.com/ralphwetzel/node-red-context-monitor/main/resources/object_monitor.png"
+    style="min-width: 474px; width: 474px; align: center; border: 1px solid lightgray;"/>
+
+Code in a `function` node:
+
+``` javascript
+    // suppose, test_flow = { prop: "value" }
+    let obj = flow.get("test_flow");
+    obj.prop = "new";
+```
+
+Message sent by the node:
+
+<img alt="flow" src="https://raw.githubusercontent.com/ralphwetzel/node-red-context-monitor/main/resources/object_msg.png"
+    style="min-width: 310px; width: 310px; align: center; border: 1px solid lightgray;"/>
+
+#### Object property monitoring
+You may define a setup that doesn't monitor the (whole) object, but only one of its properties:
+
+<img alt="flow" src="https://raw.githubusercontent.com/ralphwetzel/node-red-context-monitor/main/resources/object_prop.png"
+    style="min-width: 474px; width: 474px; align: center; border: 1px solid lightgray;"/>
+
+Such a monitor will react _only_, when this property and - if it's an object - its child properties are written to.

package/lib/monitor.js

@@ -0,0 +1,367 @@
+/*
+    node-red-context-monitor by @ralphwetzel
+    https://github.com/ralphwetzel/node-red-context-monitor
+    License: MIT
+*/
+
+let RED;
+let monitors;
+
+let init = function(_RED, cache) {
+    RED = _RED;
+    monitors = cache;
+}
+
+// *****
+// The function to wrap the NR managed context into our monitoring object
+// This cant' be done w/ a simple new Proxy(context, handler) as Proxy ensures that immutable functions
+// stay immutable - which doesn't support our intentions!
+
+// node_id: The node_id as passed to context.get
+// flow_id: The flow_id as passed to context.get
+// ctx: the contet as managed by Node-RED
+// root_id (optional): if global/flow context is re-wrapped, this is the (original) node_id
+
+let create_wrapper = function(node_id, flow_id, ctx, root_id) {
+
+    if (!RED || !monitors) {
+        console.log("*** Error while loading node-red-context-monitor:");
+        console.log("> Wrapper system not initialized.");
+        return ctx;
+    }
+
+    let context = ctx;
+    
+    var context_id = node_id;
+    if (flow_id) {
+        context_id = node_id + ":" + flow_id;
+    }
+
+    let obj = {};
+    let wrapper = new Proxy(obj, {
+
+        // *** Those 2 are valid only for function objects
+
+        // apply: function (target, thisArg, argumentsList) {
+        //     return Reflect.apply(context, thisArg, argumentsList);
+        // },
+        // construct: function(target, argumentsList, newTarget) {
+        //     return Reflect.construct(context, argumentsList, newTarget)
+        // },
+
+        // *** 'defineProperty' must reference the wrapper!
+
+        // defineProperty: function(target, propertyKey, attributes) {
+        //     return Reflect.defineProperty(context, propertyKey, attributes);
+        // },
+
+        deleteProperty: function(target, propertyKey) {
+            return Reflect.deleteProperty(context, propertyKey);
+        },
+        get: function (target, propertyKey, receiver) {
+            if (["set", "get", "keys"].indexOf(propertyKey) > -1) {
+                return target[propertyKey];
+            } else if (propertyKey == "flow") {
+                // create a wrapper for the flow context
+                let flow_context = context.flow;
+                if (!flow_context) {
+                    return;
+                }
+                return create_wrapper(flow_id, undefined, flow_context, node_id);
+            } else if (propertyKey == "global") {
+                // create a wrapper for global context
+                let global_context = context.global;
+                if (!global_context) {
+                    return;
+                }
+                return create_wrapper('global', undefined, global_context, node_id);
+            }
+            return Reflect.get(context, propertyKey, receiver);
+        },
+        getOwnPropertyDescriptor: function (target, propertyKey) {
+            return Reflect.getOwnPropertyDescriptor(context, propertyKey);
+        },
+        getPrototypeOf: function (target){
+            Reflect.getPrototypeOf(context);
+        },
+        has: function (target, propertyKey){
+            return Reflect.has(context, propertyKey);
+        },
+        isExtensible: function (target) {
+            return Reflect.isExtensible(context);
+        },
+        ownKeys: function (target) {
+            return Reflect.ownKeys(context);
+        },
+        preventExtensions: function (target) {
+            return Reflect.preventExtensions(context);
+        },
+        set: function (target, propertyKey, value, receiver) {
+            return Reflect.set(context, propertyKey, value, receiver);
+        },
+        setPrototypeOf: function (target, prototype) {
+            return Reflect.setPrototypeOf(context, prototype)
+        }
+    });
+
+    Object.defineProperties(wrapper, {
+        get: {
+            value: function(key, storage, callback) {
+
+                let create_object_wrapper = function(object, getter_key) {
+
+                    let handler = {
+                        get: (target, property, receiver) => {
+                            let getted = Reflect.get(target, property, receiver);
+
+                            // if getted is an object, wrap this (again) 
+                            // to ensure monitoring in case of direct reference access
+                            if (
+                                typeof getted === 'object' &&
+                                !Array.isArray(getted) &&
+                                getted !== null
+                            ) { 
+                                let prop_chain = property;
+                                if (getter_key?.length) {
+                                    prop_chain = getter_key + "." + prop_chain;
+                                }
+                                return create_object_wrapper(getted, prop_chain);
+                            }
+                            return getted;
+                        },
+                        set: function(target, propertyKey, value, receiver) {
+                            // this is the monitoring function!
+                            let previous_value = Reflect.get(target, propertyKey, receiver);
+                            res = Reflect.set(target, propertyKey, value, receiver);
+
+                            let prop_chain = propertyKey;
+                            if (getter_key?.length) {
+                                prop_chain = getter_key + "." + prop_chain;
+                            }
+
+                            trigger(root_id ?? node_id, context_id, key, value, previous_value, prop_chain);
+                            return res;
+                        }
+                    };
+
+                    return new Proxy(object, handler);
+
+                }
+
+                let create_array_wrapper = function(object, getter_key) {
+
+                    let handler = {
+                        get: (target, property, receiver) => {
+                            let getted = Reflect.get(target, property, receiver);
+
+                            if (
+                                typeof getted === 'object' &&
+                                Array.isArray(getted)
+                            ) { 
+                                let prop_chain = property;
+                                if (getter_key?.length) {
+                                    prop_chain = getter_key + "." + prop_chain;
+                                }
+                                return create_object_wrapper(getted, prop_chain);
+                            }
+                            return getted;
+                        },
+                        set: function(target, propertyKey, value, receiver) {
+                            // this is the monitoring function!
+                            let previous_value = Reflect.get(target, propertyKey, receiver);
+                            res = Reflect.set(target, propertyKey, value, receiver);
+
+                            let prop_chain = propertyKey;
+                            if (getter_key?.length) {
+                                prop_chain = getter_key + "." + prop_chain;
+                            }
+
+                            trigger(root_id ?? node_id, context_id, key, value, previous_value, prop_chain);
+                            return res;
+                        }
+                    };
+
+                    return new Proxy(object, handler);
+
+                }
+
+                let apply_wrapper = function (getted) {
+                    if (
+                        typeof getted === 'object' &&
+                        !Array.isArray(getted) &&
+                        getted !== null
+                    ) { 
+                        return create_object_wrapper(getted);
+                    }
+                    return getted;
+                }
+
+                if (!callback && typeof storage === 'function') {
+                    callback = storage;
+                    storage = undefined;
+                }
+
+                if (callback) {
+
+                    if (typeof callback !== 'function'){
+                        throw new Error("Callback must be a function");
+                    }
+
+                    let callback_wrapper = function(err, value) {
+                        let result = apply_wrapper(value);
+                        callback(err, result);
+                    }
+
+                    context.get(key, storage, callback_wrapper);
+                    return;
+                }
+
+                // be explicit: no (!!) callback here
+                let getted_value = context.get(key, storage);
+                return apply_wrapper(getted_value);
+
+            }
+        },
+        set: {
+            value: function(key, value, storage, callback) {
+
+                // this is the monitoring function!
+                let previous_value = context.get(key, storage);
+
+                if (!callback && typeof storage === 'function') {
+                    callback = storage;
+                    storage = undefined;
+                }
+
+                if (callback) {
+
+                    if (typeof callback !== 'function'){
+                        throw new Error("Callback must be a function");
+                    }
+
+                    let callback_wrapper = function(err, res) {
+                        // intercept the callback & report success!
+                        if (!err) {
+                            trigger(root_id ?? node_id, context_id, key, value, previous_value);
+                        }
+                        return callback(err, res);
+                    }
+
+                    return context.set(key, value, storage, callback_wrapper);
+                }
+
+                let res = context.set(key, value, storage);
+                trigger(root_id ?? node_id, context_id, key, value, previous_value);
+                return res;
+            }
+        },
+        keys: {
+            value: function(storage, callback) {
+                return context.keys(storage, callback);
+            }
+        }
+    });
+
+    return wrapper;
+}
+
+// *****
+// The function to trigger the context-monitoring nodes
+
+// root_id: The node.id that wrote to the context
+// context_id: The context (id) that was written to
+// key: The key (in context) that ws written to
+// new_value: The value written
+// previous_value: The value over-written
+// prop_chain: In case the context is a (nested) object, the sequence of property keys.
+
+let trigger = function(root_id, context_id, key, new_value, previous_value, prop_chain) {
+
+    function trigger_receivers(monitoring_nodes, message) {
+        monitoring_nodes.forEach(node => {
+            let n = RED.nodes.getNode(node.id);
+            if (n) {
+
+                let msg = RED.util.cloneMessage(message);
+
+                msg.monitoring = {
+                    "scope": node.data.scope,
+                    "source": root_id
+                }
+
+                switch (node.data.scope) {
+                    case "global":
+                        msg.monitoring.key = node.data.key;
+                        break;
+                    case "flow":
+                        msg.monitoring.flow = node.data.flow;
+                        msg.monitoring.key = node.data.key;
+                        break;
+                    case "node":
+                        msg.monitoring.flow = node.data.flow;
+                        msg.monitoring.node = node.data.node;
+                        msg.monitoring.key = node.data.key;
+                        break;
+                }
+
+                n.receive(msg);    
+            }    
+        });
+    }
+
+    let kc = key;
+    if (prop_chain?.length) {
+        kc += "." + prop_chain;
+    }
+
+    let keys = [];
+    try {
+        keys = RED.util.normalisePropertyExpression(kc);
+    } catch {}
+
+    for (let i=keys.length; i>0; i--) {
+
+        let cidk = context_id + ":" + keys.slice(0,i).join(".");
+        let mons = monitors[cidk] ?? [];
+        
+        if (mons.length) {
+            let msg = {
+                payload: new_value,
+                previous: previous_value,
+                // do this once already here!
+                // ToDo: For non primitives: run a fast comparisor
+                changed: new_value != previous_value
+            }
+
+            msg.topic = kc;
+
+            trigger_receivers(mons, msg);    
+        }
+    }
+}
+
+// End: The function ....
+// *****
+
+module.exports = {
+    init: init,
+    create_wrapper: create_wrapper
+}
+
+if (process.env.TESTING_CONTEXT_MONITOR) {
+
+    module.exports["trace"] = function(id) {
+
+        if (!RED || !monitors) {
+            console.log("*** Error while testing node-red-context-monitor:");
+            console.log("> Wrapper system not initialized.");
+            return;
+        }
+    
+        if (id) {
+            return monitors[id];
+        }
+        return monitors;
+    }
+}
+

package/monitor.html

@@ -5,12 +5,47 @@
 -->
 
 <script type="text/javascript">
+
+    function validate_context_key(key) {
+        try {
+            var parts = RED.utils.normalisePropertyExpression(key);
+
+            // If there's a changable part (e.g. test[msg.payload])
+            // this will become an array type in parts.
+            // Those might be ok for other situtions, but not here!
+            for (i=0; i<parts.length; i++) {
+                let p = parts[i];
+                if (Array.isArray(p)) {
+                    return false;
+                }
+            }
+            return true;
+        } catch (err) {
+            return false;
+        }
+    }
+
     RED.nodes.registerType('context-monitor',{
         category: 'input',
         color: '#b0b0b0',
         defaults: {
             name: {value:""},
-            monitoring: {value:[]}
+            monitoring: { 
+                value: [],
+                validate: function(scopes, opt) {
+                    let msg;
+                    if (!scopes || scopes.length === 0) { return true }
+                    for (let i=0; i<scopes.length; i++) {
+                        let scope = scopes[i];
+                        if (!validate_context_key(scope.key)) {
+                            return RED._("node-red:change.errors.invalid-prop", {
+                                property: scope.key
+                            });
+                        }
+                    }
+                    return true;
+                }
+            }
         },
         inputs: 0,
         outputs: 2,
@@ -41,7 +76,8 @@
             function add_context(tpl) {
                 let c = {
                     "scope": tpl.scope ?? "global",
-                    "flow": tpl.flow,
+                    // decode "this flow" marker
+                    "flow": ("." === tpl.flow) ? node.z : tpl.flow,
                     "node": tpl.node,
                     "key": tpl.key ?? ""
                 }
@@ -157,8 +193,8 @@
                     });
 
                     let flow_opts = [];
-                    let group_opts = [];
-                    let node_opts = [];
+                    // let group_opts = [];
+                    let node_opts;
 
                     RED.nodes.eachWorkspace( cb => {
                         flow_opts.push({
@@ -194,7 +230,8 @@
                         // if ($(`#context-scope-${index}`).typedInput("value") == "group") {
                         //     $(`#context-scope-key-${index}`).prop("disabled", gol < 1);
                         // }
-                                                
+                                           
+                        node_opts = [];
                         RED.nodes.eachNode( n => {
 
                             if (n.z == value) {
@@ -271,6 +308,11 @@
                             data.key = $(this).val();
                             node.dirty = true;
                         }
+                        $(this).toggleClass("input-error", !validate_context_key($(this).val()));
+                    });
+
+                    $(`#context-scope-key-${index}`).on( "input", function () {
+                        $(this).toggleClass("input-error", !validate_context_key($(this).val()));
                     });
 
                     // initialize the form
@@ -303,7 +345,7 @@
                         }
                     }
 
-                    $(`#context-scope-key-${index}`).val(data.key);
+                    $(`#context-scope-key-${index}`).val(data.key).toggleClass("input-error", !validate_context_key(data.key));
 
                     _initing = false;
                 },
@@ -379,8 +421,12 @@
                     //     break;
                     case "node":
                         delete data.group;
-                }
+                                        }
 
+                if (data.flow == node.z) {
+                    // set a special marker that 'this flow' shall be referenced
+                    data.flow = ".";
+                }
             })
 
             node.monitoring = ctx;

package/monitor.js

@@ -5,270 +5,100 @@
 */
 
 const fs = require('fs-extra');
-const os = require("os");
 const path = require("path");
-
-let error_header = "*** Error while loading node-red-context-monitor:";
+const monitor = require('./lib/monitor.js');
 
 // this used to be the cache of ctx triggered @ set
 // ... that's why it's the set_cache! 
 let set_cache = {};
 
-let _RED;
+// *****
+// Patch support: Scan the require database for the path to a to-be-required file
 
-// ****
-// Copied from node-red-mcu-plugin:
-// Patch support function: Calculate the path to a to-be-required file
+let require_cache = {
+    ".": require.main
+}
 
-function get_require_path(req_path) {
+function scan_for_require_path(req_path) {
 
-    let rm = require.main.path;
+    let found;
 
-    try {
-        let stat = fs.lstatSync(rm);
-        if (!stat.isDirectory()) {
-            console.log(error_header);
-            console.log("require.main.path is not a directory.");
-            return;
+    if (process.env.NODE_RED_HOME) {
+        found = path.join(process.env.NODE_RED_HOME, "..", req_path);
+        console.log("@f", found);
+        if (fs.existsSync(found)) {
+            return found;
         }
-    } catch (err) {
-        console.log(err);
-        console.log(error_header);
-        if (err.code == 'ENOENT') {
-            console.log("require.main.path not found.");
-        } else {
-            console.log("Error while handling require.main.path.")
-        }
-        return null;
     }
 
-    // split path into segments ... the safe way
-    rm = path.normalize(rm);
-    let rms = []
-    let rmp;
-    do {
-        rmp = path.parse(rm);
-        if (rmp.base.length > 0) {
-            rms.unshift(rmp.base);
-            rm = rmp.dir;    
-        }
-    } while (rmp.base.length > 0)
+    let runner = 0;
 
-    let rmsl = rms.length;
+    while (runner < Object.keys(require_cache).length) {
 
-    if (rms.includes("packages"))  {
-        if (rms[rmsl-3]=="packages" && rms[rmsl-2]=="node_modules" && rms[rmsl-1]=="node-red") {
-            // dev:     [...]/node-red/packages/node_modules/node-red
-            // install: [...]/lib/node_modules/node-red
-            // pi:      /lib/node_modules/node-red/
+        let key = Object.keys(require_cache)[runner];
+        let entry = require_cache[key];
 
-            // dev:     [...]/node-red/packages/node_modules/@node-red
-            // install: [...]/lib/node_modules/node-red/node_modules/@node-red
-            // pi:      /lib/node_modules/node-red/node_modules/@node-red
-            rms.splice(-2);
+        if (entry.id?.includes(req_path)) {
+            found = entry.id;
+            break;
         }
+
+        let cc = entry.children;
+        cc.forEach(c => {
+            if (!(c.id in require_cache)) {
+                require_cache[c.id] = c;
+            }
+        });
+    
+        runner += 1;
     }
 
-    // compose things again...
-    req_path = req_path.split("/");
-    let p = path.join(rmp.root, ...rms, ...req_path);
-
-    if (!fs.existsSync(p)) {
-        console.log(error_header)
-        console.log("Failed to calculate correct patch path.");
-        console.log("Please raise an issue @ our GitHub repository, stating the following information:");
-        console.log("> require.main.path:", require.main.path);
-        console.log("> utils.js:", p);
-        return null;
+    if (found) {
+        if (!fs.existsSync(found)) {
+            console.log("*** Error while loading node-red-context-monitor:")
+            console.log("Failed to calculate path to required file.");
+            console.log("Please raise an issue @ our GitHub repository, stating the following information:");
+            console.log("> scanned for:", req_path);
+            console.log("> found:", found);
+            return;
+        }
     }
 
-    return p;
+    console.log(found);
+    return found;
 }
 
 // End: "Patch support ..."
 // *****
 
 // *****
-// Make available the Context Manager
+// Make available & patch the Context Manager
 
-const context_manager_path = get_require_path("node_modules/@node-red/runtime/lib/nodes/context/index.js");
-if (!context_manager_path) return;
-const context_manager = require(context_manager_path);
+let context_manager;
 
-// The function to wrap the NR managed context into our monitoring object
-// This cant' be done w/ a simple new Proxy(context, handler) as Proxy ensures that immutable functions
-// stay immutable - which doesn't support our intentions!
+// When running a test, NODE_RED_HOME is not defined.
+if (process.env.NODE_RED_HOME && !process.env.TESTING_CONTEXT_MONITOR) {
 
-let create_wrapper = function(node_id, flow_id, ctx) {
+    let context_manager_path = scan_for_require_path("@node-red/runtime/lib/nodes/context");
+    if (context_manager_path) {
 
-    let context = ctx;
+        context_manager = require(context_manager_path);
     
-    var context_id = node_id;
-    if (flow_id) {
-        context_id = node_id + ":" + flow_id;
-    }
-
-    let obj = {};
-    let wrapper = new Proxy(obj, {
-
-        // *** Those 2 are valid only for function objects
-
-        // apply: function (target, thisArg, argumentsList) {
-        //     return Reflect.apply(context, thisArg, argumentsList);
-        // },
-        // construct: function(target, argumentsList, newTarget) {
-        //     return Reflect.construct(context, argumentsList, newTarget)
-        // },
-
-        // *** 'defineProperty' must reference the wrapper!
-
-        // defineProperty: function(target, propertyKey, attributes) {
-        //     return Reflect.defineProperty(context, propertyKey, attributes);
-        // },
-
-        deleteProperty: function(target, propertyKey) {
-            return Reflect.deleteProperty(context, propertyKey);
-        },
-        get: function (target, propertyKey, receiver) {
-            if (["set", "get", "keys"].indexOf(propertyKey) > -1) {
-                return target[propertyKey];
-            } else if (propertyKey == "flow") {
-                // create a wrapper for the flow context
-                let flow_context = context.flow;
-                if (!flow_context) {
-                    return;
-                }
-                return create_wrapper(flow_id, undefined, flow_context);
-            } else if (propertyKey == "global") {
-                // create a wrapper for global context
-                let global_context = context.global;
-                if (!global_context) {
-                    return;
-                }
-                return create_wrapper('global', undefined, global_context);
-            }
-            return Reflect.get(context, propertyKey, receiver);
-        },
-        getOwnPropertyDescriptor: function (target, propertyKey) {
-            return Reflect.getOwnPropertyDescriptor(context, propertyKey);
-        },
-        getPrototypeOf: function (target){
-            Reflect.getPrototypeOf(context);
-        },
-        has: function (target, propertyKey){
-            return Reflect.has(context, propertyKey);
-        },
-        isExtensible: function (target) {
-            return Reflect.isExtensible(context);
-        },
-        ownKeys: function (target) {
-            return Reflect.ownKeys(context);
-        },
-        preventExtensions: function (target) {
-            return Reflect.preventExtensions(context);
-        },
-        set: function (target, propertyKey, value, receiver) {
-            return Reflect.set(context, propertyKey, value, receiver);
-        },
-        setPrototypeOf: function (target, prototype) {
-            return Reflect.setPrototypeOf(context, prototype)
+        // patching into getContext (exported as 'get')
+        const orig_context_get = context_manager.get;
+        context_manager.get = function(nodeId, flowId) {
+            let context = orig_context_get(nodeId, flowId);
+            return monitor.create_wrapper(nodeId, flowId, context);
         }
-    });
-
-    Object.defineProperties(wrapper, {
-        get: {
-            value: function(key, storage, callback) {
-                return context.get(key, storage, callback);
-            }
-        },
-        set: {
-            value: function(key, value, storage, callback) {
-                // this is the monitoring function!
-                let previous_value = context.get(key, storage);
-                let res = context.set(key, value, storage, callback);
-                trigger(context_id + ":" + key, value, previous_value);
-                return res;
-            }
-        },
-        keys: {
-            value: function(storage, callback) {
-                return context.keys(storage, callback);
-            }
+    
+        // patching into getFlowContext
+        const orig_get_flow_context = context_manager.getFlowContext;
+        context_manager.getFlowContext = function(flowId, parentFlowId) {
+            let flow_context = orig_get_flow_context(flowId, parentFlowId);
+            return monitor.create_wrapper(flowId, undefined, flow_context);
         }
-    });
-
-    return wrapper;
-}
-
-// *****
-// The function to trigger the context-monitoring nodes
-
-let trigger = function(context_key_id, new_value, previous_value) {
-
-    function trigger_receivers(cache, message) {
-        cache.forEach(node => {
-            let n = _RED.nodes.getNode(node.id);
-            if (n) {
-
-                let msg = _RED.util.cloneMessage(message);
-
-                msg.topic = node.data.key;
-                msg.monitoring = {
-                    "scope": node.data.scope,
-                }
-
-                switch (node.data.scope) {
-                    case "global":
-                        msg.monitoring.key = node.data.key;
-                        break;
-                    case "flow":
-                        msg.monitoring.flow = node.data.flow;
-                        msg.monitoring.key = node.data.key;
-                        break;
-                    case "node":
-                        msg.monitoring.flow = node.data.flow;
-                        msg.monitoring.node = node.data.node;
-                        msg.monitoring.key = node.data.key;
-                        break;
-                }
-
-                n.receive(msg);    
-            }    
-        });
-    }
-
-    let cache = set_cache[context_key_id] ?? [];
-    let msg = {
-        payload: new_value,
-        previous: previous_value
+    
     }
-    trigger_receivers(cache, msg);
-
-    // if (new_value !== previous_value) {
-    //     let cache = change_cache[context_key_id] ?? [];
-    //     let msg = {
-    //         payload: new_value,
-    //         previous: previous_value
-    //     }
-    //     trigger_receivers(cache, msg);
-    // }
-}
-
-// End: The function ....
-// *****
-
-// patching into getContext (exported as 'get')
-const orig_context_get = context_manager.get;
-context_manager.get = function(nodeId, flowId) {
-    let context = orig_context_get(nodeId, flowId);
-    return create_wrapper(nodeId, flowId, context);
-}
-
-// patching into getFlowContext
-const orig_get_flow_context = context_manager.getFlowContext;
-context_manager.getFlowContext = function(flowId, parentFlowId) {
-    let flow_context = orig_get_flow_context(flowId, parentFlowId);
-    return create_wrapper(flowId, undefined, flow_context);
 }
 
 // End: "Make available ..."
@@ -279,31 +109,53 @@ context_manager.getFlowContext = function(flowId, parentFlowId) {
 
 module.exports = function(RED) {
 
-    // catch this here!
-    // necessary for trigger function to map node_id -> node object.
-    _RED = RED;
+    // Catch RED here & provide it to the monitor!
+    // It's necessary for trigger function to map node_id -> node object.
+    monitor.init(RED, set_cache);
 
     function ContextMonitor(config) {
         RED.nodes.createNode(this,config);
         var node = this;
 
-        node.data = config.monitoring;
+        let scopes = config.monitoring ?? [];
+        node.data = scopes;
+
         node.monitoring = [];
 
-        config.monitoring.forEach( data => {
+        scopes.forEach( data => {
 
             if (!data.key) return;
 
+            // support for complex keys
+            // test["mm"].value becomes test.mm.value
+            let key = data.key;
+
+            try {
+                let key_parts = RED.util.normalisePropertyExpression(key);
+                for (i=0; i<key_parts.length; i++) {
+                    if (Array.isArray(key_parts[i])) {
+                        return;
+                    }
+                }
+                key = key_parts.join('.');
+            } catch {
+                return;
+            }
+
+            if ("." === data.flow) {
+                data.flow = node.z;
+            }
+
             let ctx = "global";
             switch (data.scope) {
                 case "global":
-                    ctx = `global:${data.key}`;
+                    ctx = `global:${key}`;
                     break;
                 case "flow":
-                    ctx = `${data.flow}:${data.key}`;
+                    ctx = `${data.flow}:${key}`;
                     break;
                 case "node":
-                    ctx = `${data.node}:${data.flow}:${data.key}`;
+                    ctx = `${data.node}:${data.flow}:${key}`;
                     break;
                 default:
                     return;
@@ -325,9 +177,11 @@ module.exports = function(RED) {
             
             // unfold & check if changed
             let prev = msg.previous;
+            let changed = msg.changed;
             delete msg.previous;
+            delete msg.changed;
 
-            if (msg.payload !== prev) {
+            if (changed) {
                 // if changed, clone & emit @ second output terminal
                 let m = RED.util.cloneMessage(msg);
                 delete m._msgid;
@@ -343,12 +197,18 @@ module.exports = function(RED) {
         node.on("close",function() {
             // remove this nodes ctx(s) from the trigger list
             node.monitoring.forEach( ctx => {
-                set_cache[ctx] = set_cache[ctx].filter( n => {
-                    return n.id !== node.id;
-                })
+                let sc = set_cache[ctx];
+                if (sc) {
+                    set_cache[ctx] = sc.filter( n => {
+                        return n.id !== node.id;
+                    })
+                    if (set_cache[ctx].length < 1) {
+                        delete set_cache[ctx];
+                    }
+                }
             })
         });
     }
 
     RED.nodes.registerType("context-monitor",ContextMonitor);
-}
+}

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "@ralphwetzel/node-red-context-monitor",
-  "version": "1.0.0",
+  "version": "1.1.0",
   "description": "A Node-RED node to monitor a context.",
   "main": "monitor.js",
   "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1"
+    "test": "mocha \"test/**/*_spec.js\""
   },
   "repository": {
     "type": "git",
@@ -27,9 +27,23 @@
   },
   "homepage": "https://github.com/ralphwetzel/node-red-context-monitor#readme",
   "dependencies": {
-    "fs-extra": "^11.1.1"
+    "fs-extra": "^11.1.1",
+    "node-red": "^3.1.0"
   },
   "engines": {
-    "node": ">=16.0.0"
-}
+    "node": ">=14.0.0"
+  },
+  "devDependencies": {
+    "mocha": "^10.2.0",
+    "node-red-node-test-helper": "^0.3.2"
+  },
+  "files": [
+    "/examples",
+    "/lib",
+    "/resources",
+    "LICENSE",
+    "monitor.*",
+    "package.json",
+    "README.md"
+  ]
 }

package/.github/workflows/npm_publish.yml

@@ -1,33 +0,0 @@
-# This workflow will run tests using node and then publish a package to GitHub Packages when a release is created
-# For more information see: https://help.github.com/actions/language-and-framework-guides/publishing-nodejs-packages
-
-name: "NPM Publish"
-
-on:
-  release:
-    types: [created]
-
-jobs:
-  build:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v3
-      - uses: actions/setup-node@v3
-        with:
-          node-version: 16
-      # - run: npm ci
-      # - run: npm test
-
-  publish-npm:
-    needs: build
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v3
-      - uses: actions/setup-node@v3
-        with:
-          node-version: 16
-          registry-url: https://registry.npmjs.org/
-      # - run: npm ci
-      - run: npm publish --access public
-        env:
-          NODE_AUTH_TOKEN: ${{secrets.npm_access_token}}