node-red-contrib-join-wait 0.5.3 → 0.6.0

package/lib/config.js

@@ -0,0 +1,26 @@
+'use strict';
+
+// Accept either a real array (new editor format) or a JSON-encoded string
+// (legacy editor format). Returns false for anything else so callers can
+// detect "not configured".
+function normalizePaths(value) {
+    if (Array.isArray(value)) return value;
+    if (typeof value !== 'string' || value === '') return false;
+    try {
+        const json = JSON.parse(value);
+        return Array.isArray(json) ? json : false;
+    } catch (_err) {
+        return false;
+    }
+}
+
+function hasDuplicatePath(arr) {
+    return arr.some((p, i) => arr.indexOf(p) !== i);
+}
+
+function compileRegex(arr) {
+    if (!Array.isArray(arr)) return arr;
+    return arr.map((pattern) => (pattern instanceof RegExp ? pattern : new RegExp(pattern)));
+}
+
+module.exports = { normalizePaths, hasDuplicatePath, compileRegex };

package/lib/matcher.js

@@ -0,0 +1,114 @@
+'use strict';
+
+// Pure path-matching helpers. No node-red dependencies — easy to unit test.
+
+function flatten(arr) {
+    return [].concat.apply([], arr);
+}
+
+function condenseWithCount(arr) {
+    const map = arr.reduce((m, key) => m.set(key, (m.get(key) || 0) + 1), new Map());
+    return Array.from(map, ([name, value]) => ({ name, value }));
+}
+
+function regexIndexOf(arr, needle) {
+    for (let i = 0; i < arr.length; i++) {
+        if (arr[i].test(needle)) return i;
+    }
+    return -1;
+}
+
+function matchesAny(val, patterns, useRegex) {
+    return useRegex ? patterns.some((p) => p.test(val)) : patterns.includes(val);
+}
+
+function anyMatches(values, patterns, useRegex) {
+    return values.some((v) => matchesAny(v, patterns, useRegex));
+}
+
+function countPathsAnyOrder(keys, waitMap, useRegex) {
+    const used = new Set();
+    return waitMap.map((p) => {
+        let count = 0;
+        for (let i = 0; i < keys.length; i++) {
+            if (used.has(i)) continue;
+            const matched = useRegex ? p.name.test(keys[i]) : p.name === keys[i];
+            if (!matched) continue;
+            used.add(i);
+            count++;
+        }
+        return count < p.value ? count : true;
+    });
+}
+
+// Result shape returned by findAllPaths*:
+//   { matched: true }                 — wait paths satisfied; caller drains.
+//   { matched: false, keep: <number> }— not yet; caller may expire trailing
+//                                       entries past `keep`.
+const MATCHED = Object.freeze({ matched: true });
+
+function findAllPathsAnyOrder(arr, waitPaths, useRegex) {
+    const waitMap = condenseWithCount(waitPaths);
+    const keys = flatten(arr);
+    const result = countPathsAnyOrder(keys, waitMap, useRegex);
+
+    if (result.every((p) => p === true)) return MATCHED;
+
+    const originalString = result.toString();
+    for (let i = 0; i < arr.length; i++) {
+        const newKeys = flatten(arr.slice(i + 1));
+        const expireByOne = countPathsAnyOrder(newKeys, waitMap, useRegex);
+        if (originalString !== expireByOne.toString()) {
+            return { matched: false, keep: arr.length - i };
+        }
+    }
+
+    /* c8 ignore next */
+    return { matched: false, keep: 0 };
+}
+
+function findAllPathsExactOrder(arr, waitPaths, useRegex) {
+    let start = 0;
+    let marker = false;
+
+    for (let i = 0; i < arr.length; i++) {
+        for (let j = 0; j < arr[i].length; j++) {
+            const p = arr[i][j];
+
+            const offBy = marker === false ? 0 : marker + 1;
+            const unusedWaitPaths = waitPaths.slice(offBy);
+            let index = useRegex ? regexIndexOf(unusedWaitPaths, p) : unusedWaitPaths.indexOf(p);
+
+            if (index === -1) {
+                if (offBy > 0) {
+                    index = useRegex ? regexIndexOf(waitPaths, p) : waitPaths.indexOf(p);
+                    if (index > 0) marker = false;
+                }
+            } else {
+                index += offBy;
+            }
+
+            if (index === 0) {
+                start = i;
+            } else if (index === -1 || marker === false) {
+                continue;
+            } else if (index < marker || index > marker + 1) {
+                marker = false;
+                continue;
+            }
+
+            if (index === waitPaths.length - 1) return MATCHED;
+
+            marker = index;
+        }
+    }
+
+    return { matched: false, keep: marker === false ? 0 : arr.length - start };
+}
+
+module.exports = {
+    matchesAny,
+    anyMatches,
+    findAllPathsAnyOrder,
+    findAllPathsExactOrder,
+};

package/lib/persist.js

@@ -0,0 +1,60 @@
+'use strict';
+
+// Persistence adapter over Node-RED's context store API. Production code
+// passes `node.context()` (or any object exposing `get/set` with the
+// callback signature). Tests pass an in-memory stub.
+//
+// Using the context store is the idiomatic Node-RED way:
+//  - Default memory store keeps queues across deploys (in-process).
+//  - A persistent store configured in settings.js (e.g. localfilesystem)
+//    keeps queues across full restarts.
+// The store is selected per-instance via the `persistStore` config field.
+
+const KEY = 'paths';
+
+function load(ctx, store) {
+    return new Promise((resolve) => {
+        try {
+            ctx.get(KEY, store, (err, value) => {
+                /* c8 ignore next 4 */
+                if (err) {
+                    resolve({});
+                    return;
+                }
+                resolve(value && typeof value === 'object' ? value : {});
+            });
+            /* c8 ignore next 3 */
+        } catch (_err) {
+            resolve({});
+        }
+    });
+}
+
+function save(ctx, store, paths) {
+    // Strip non-serializable timeOut handles before writing.
+    const serializable = {};
+    for (const t of Object.keys(paths)) {
+        serializable[t] = { queue: paths[t].queue };
+    }
+    return new Promise((resolve) => {
+        try {
+            ctx.set(KEY, serializable, store, () => resolve());
+            /* c8 ignore next 3 */
+        } catch (_err) {
+            resolve();
+        }
+    });
+}
+
+function clear(ctx, store) {
+    return new Promise((resolve) => {
+        try {
+            ctx.set(KEY, undefined, store, () => resolve());
+            /* c8 ignore next 3 */
+        } catch (_err) {
+            resolve();
+        }
+    });
+}
+
+module.exports = { load, save, clear, KEY };

package/lib/store.js

@@ -0,0 +1,64 @@
+'use strict';
+
+// Resolves which Node-RED context store the join-wait node should use
+// for its queue. Order of preference:
+//
+//   1. The explicit per-node `Persist store` (config.persistStore).
+//   2. If "Preserve queue" is on AND the default store is memory AND
+//      there's a non-memory named store, pick that — saves the user
+//      from having to set Persist store on every node just to get
+//      restart persistence.
+//   3. Otherwise undefined (use Node-RED's default store).
+//
+// The contextStorage entry shape supported by Node-RED:
+//   { default: { module: 'memory' }, file: { module: 'localfilesystem' } }
+//   { default: 'memoryOnly', memoryOnly: { module: 'memory' }, ... }
+//   { default: 'memory' }                     (string shorthand)
+
+// Returns the module string for a contextStorage entry. The entry may itself
+// be a module-config object (`{ module: 'memory' }`) or a plain module name
+// string (`'memory'`).
+function entryModule(entry) {
+    if (!entry) return undefined;
+    if (typeof entry === 'string') return entry;
+    if (typeof entry === 'object') return entry.module;
+    /* c8 ignore next */
+    return undefined;
+}
+
+// `default` may itself be a string alias to another named entry (e.g.
+// `default: 'memoryOnly'` referring to a named `memoryOnly` store).
+// Follow the alias to find the actual module.
+function resolveDefaultModule(contextStorage) {
+    const def = contextStorage.default;
+    if (!def) return undefined;
+    if (typeof def === 'string' && contextStorage[def]) {
+        return entryModule(contextStorage[def]);
+    }
+    return entryModule(def);
+}
+
+function resolveContextStore(contextStorage, configStore, persistQueue) {
+    if (configStore) return configStore;
+    if (!persistQueue) return undefined;
+    if (!contextStorage || typeof contextStorage !== 'object') return undefined;
+
+    const defaultModule = resolveDefaultModule(contextStorage);
+    // If the default is anything other than memory (or unset → memory) it'll
+    // already survive restarts — nothing to upgrade.
+    if (defaultModule && defaultModule !== 'memory') return undefined;
+
+    // Look for a persistent named store. Skip the `default` key itself, and
+    // any entries whose resolved module is memory.
+    const defaultAlias = typeof contextStorage.default === 'string' ? contextStorage.default : undefined;
+    for (const name of Object.keys(contextStorage)) {
+        if (name === 'default') continue;
+        if (name === defaultAlias) continue;
+        const m = entryModule(contextStorage[name]);
+        if (m && m !== 'memory') return name;
+    }
+
+    return undefined;
+}
+
+module.exports = { resolveContextStore };

package/package.json

@@ -1,61 +1,94 @@
 {
-  "author": "Daniel Caspi <dan@element26.net>",
-  "bugs": {
-    "url": "https://github.com/dxdc/node-red-contrib-join-wait/issues"
-  },
-  "dependencies": {
-    "jsonata": "^1.8.5",
-    "node-persist": "^2.1.0"
-  },
-  "description": "Waits for incoming messages from different input paths to arrive within a fixed time window.",
-  "devDependencies": {
-    "@types/node-red": "^1.1.1",
-    "eslint": "^8.1.0",
-    "eslint-plugin-mocha": "^9.0.0",
-    "markdown-spellcheck": "^1.3.1",
-    "mocha": "^9.1.3",
-    "node-red": "^2.1.3",
-    "node-red-node-test-helper": "^0.2.7",
-    "nyc": "^15.1.0",
-    "prettier": "^2.4.1",
-    "rimraf": "^3.0.2"
-  },
-  "homepage": "https://github.com/dxdc/node-red-contrib-join-wait#readme",
-  "keywords": [
-    "node-red",
-    "join",
-    "parallel",
-    "timeout",
-    "wait",
-    "merge"
-  ],
-  "license": "MIT",
-  "licenses": [
-    {
-      "type": "MIT",
-      "url": "https://github.com/dxdc/node-red-contrib-join-wait/blob/master/LICENSE"
+    "name": "node-red-contrib-join-wait",
+    "version": "0.6.0",
+    "description": "Node-RED node that joins related messages across multiple paths within a time window — with exact-order matching, regex paths, correlation grouping, reset paths, and queue persistence. Coordinate parallel flows, synchronize events, and debounce sensors.",
+    "author": "Daniel Caspi <dan@element26.net>",
+    "license": "MIT",
+    "homepage": "https://github.com/dxdc/node-red-contrib-join-wait#readme",
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/dxdc/node-red-contrib-join-wait.git"
+    },
+    "bugs": {
+        "url": "https://github.com/dxdc/node-red-contrib-join-wait/issues"
+    },
+    "funding": [
+        {
+            "type": "individual",
+            "url": "https://paypal.me/ddcaspi"
+        },
+        {
+            "type": "github",
+            "url": "https://github.com/sponsors/dxdc"
+        }
+    ],
+    "main": "join-wait.js",
+    "engines": {
+        "node": ">=20"
+    },
+    "files": [
+        "join-wait.js",
+        "join-wait.html",
+        "lib/",
+        "icons/",
+        "examples/",
+        "LICENSE",
+        "README.md",
+        "CHANGELOG.md"
+    ],
+    "keywords": [
+        "node-red",
+        "node-red-contrib",
+        "join",
+        "merge",
+        "wait",
+        "timeout",
+        "parallel",
+        "synchronize",
+        "coordinate",
+        "correlate",
+        "correlation",
+        "barrier",
+        "gate",
+        "aggregate",
+        "sequence",
+        "debounce",
+        "regex",
+        "pattern",
+        "events",
+        "iot",
+        "home-automation"
+    ],
+    "node-red": {
+        "version": ">=3.0.0",
+        "nodes": {
+            "join-wait": "join-wait.js"
+        },
+        "examples": "examples"
+    },
+    "dependencies": {
+        "jsonata": "^2.0.5"
+    },
+    "devDependencies": {
+        "@eslint/js": "^9.10.0",
+        "@types/node-red": "^1.3.5",
+        "c8": "^10.1.2",
+        "cspell": "^8.13.3",
+        "eslint": "^9.10.0",
+        "eslint-plugin-mocha": "^10.5.0",
+        "globals": "^15.9.0",
+        "mocha": "^10.7.3",
+        "node-red": "^4.0.3",
+        "node-red-node-test-helper": "^0.3.6",
+        "prettier": "^3.3.3",
+        "should": "^13.2.3"
+    },
+    "scripts": {
+        "test": "mocha \"test/**/*_spec.js\"",
+        "coverage": "c8 --reporter=text-summary --reporter=lcov --check-coverage --lines 95 --statements 95 --functions 95 --branches 90 --exclude 'test/**' --exclude 'coverage/**' npm test",
+        "lint": "eslint .",
+        "format": "prettier --write \"{.,test,lib}/*.{js,json}\" *.html *.md",
+        "format:check": "prettier --check \"{.,test,lib}/*.{js,json}\" *.html *.md",
+        "spellcheck": "cspell \"**/*.md\""
     }
-  ],
-  "main": "join-wait.js",
-  "maintainers": [
-    "Daniel Caspi <dan@element26.net>"
-  ],
-  "name": "node-red-contrib-join-wait",
-  "node-red": {
-    "nodes": {
-      "join-wait": "join-wait.js"
-    }
-  },
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/dxdc/node-red-contrib-join-wait.git"
-  },
-  "scripts": {
-    "coverage": "nyc npm t",
-    "format": "prettier --write {.,test}/*.js *.html *.md",
-    "lint": "eslint {.,test}/*.js",
-    "spellcheck": "mdspell -r -n *.md",
-    "test": "mocha \"test/**/*_spec.js\""
-  },
-  "version": "0.5.3"
 }

package/.eslintrc.js

@@ -1,24 +0,0 @@
-module.exports = {
-    env: {
-        es6: true,
-        node: true,
-        mocha: true,
-    },
-    extends: ['eslint:recommended', 'plugin:mocha/recommended'],
-    globals: {
-        Atomics: 'readonly',
-        SharedArrayBuffer: 'readonly',
-    },
-    parserOptions: {
-        ecmaVersion: 2018,
-        sourceType: 'module',
-    },
-    plugins: ['mocha'],
-    rules: {
-        indent: ['error', 4, { "SwitchCase": 1 }],
-        'linebreak-style': ['error', 'unix'],
-        quotes: ['error', 'single'],
-        semi: ['error', 'always'],
-        'no-console': 'off',
-    },
-};

package/.github/FUNDING.yml

@@ -1,12 +0,0 @@
-# These are supported funding model platforms
-
-github: dxdc
-patreon: # Replace with a single Patreon username
-open_collective: # Replace with a single Open Collective username
-ko_fi: # Replace with a single Ko-fi username
-tidelift: # Replace with a single Tidelift platform-name/package-name e.g., npm/babel
-community_bridge: # Replace with a single Community Bridge project-name e.g., cloud-foundry
-liberapay: # Replace with a single Liberapay username
-issuehunt: # Replace with a single IssueHunt username
-otechie: # Replace with a single Otechie username
-custom: # Replace with up to 4 custom sponsorship URLs e.g., ['link1', 'link2']

package/.nycrc.json

@@ -1,11 +0,0 @@
-{
-    "reporter": [
-        "lcov",
-        "text-summary"
-    ],
-    "lines": 100,
-    "statements": 100,
-    "functions": 100,
-    "branches": 100,
-    "check-coverage": true
-}

package/.prettierrc

@@ -1,6 +0,0 @@
-{
-  "printWidth": 120,
-  "tabWidth": 4,
-  "trailingComma": "all",
-  "singleQuote": true
-}

package/.spelling

@@ -1,20 +0,0 @@
-# usernames
-dxdc
-mauriciom75
-
-# text
-1A
-1B
-2A
-2B
-3A
-behavior
-my_path1_test
-path_1
-path_2
-path1
-path2
-path3
-regex
-timestamp
-Venmo

package/.travis.yml

@@ -1,20 +0,0 @@
-language: node_js
-node_js:
-  - 10
-  - 12
-  - 14
-  - node
-
-install: yarn
-cache: yarn
-
-script:
-  - yarn lint
-  - yarn test
-
-deploy:
-    provider: npm
-    email: "$NPM_EMAIL"
-    api_key: "$NPM_API_KEY"
-    on:
-        tags: true

package/docs/_config.yml

@@ -1 +0,0 @@
-theme: jekyll-theme-minimal

package/test/flows.js

@@ -1,33 +0,0 @@
-const Flows = {
-    getDefault: function (options) {
-        let defaultFlow = [
-            {
-                id: 'n1',
-                type: 'join-wait',
-                paths: '["path_1", "path_2", "path_3"]',
-                pathsToExpire: '',
-                useRegex: false,
-                warnUnmatched: true,
-                pathTopic: 'paths',
-                pathTopicType: 'msg',
-                correlationTopic: '',
-                correlationTopicType: 'undefined',
-                timeout: '1',
-                timeoutUnits: '1000',
-                exactOrder: 'false',
-                firstMsg: 'true',
-                mapPayload: 'true',
-                disableComplete: false,
-                persistOnRestart: false,
-                wires: [['n2'], ['n3']],
-            },
-            { id: 'n2', type: 'helper' },
-            { id: 'n3', type: 'helper' },
-        ];
-
-        defaultFlow[0] = Object.assign(defaultFlow[0], options);
-        return defaultFlow;
-    },
-};
-
-module.exports = Flows;