n8n-nodes-variable 1.0.7 → 1.0.9

package/README.md

@@ -12,6 +12,7 @@ The **Variable** node lets you store, retrieve, update, and delete named variabl
 - **Workflow Global** — persists across executions using n8n's workflow static data
 - **Node Local** — persists for the specific node instance
 - **Custom Namespace** — workflow global storage with a fully dynamic namespace string (great for per-user / per-guild data)
+- **Cross-Workflow (Shared)** — variables are stored in a local JSON file and shared across **all** workflows on this n8n instance
 
 ---
 
@@ -94,6 +95,18 @@ cooldowns        → command cooldown per guild+user
 guild_{{$json.guild.id}} → per-guild settings
 ```
 
+### Cross-Workflow (Shared)
+
+Variables are stored in a JSON file on the n8n host at:
+
+```
+${N8N_USER_FOLDER ?? ~/.n8n}/n8n-nodes-variable-data.json
+```
+
+The file is **created automatically on first use** — no setup or dependencies required. Writes are performed atomically (write to a temporary file, then rename) to prevent corruption. Data survives instance restarts and is accessible from any workflow on the same n8n instance.
+
+> **Note:** the file lives on the n8n host machine. If you run n8n in a container or cloud environment, ensure the `.n8n` data directory is persisted to a volume so data is not lost on container restarts.
+
 ---
 
 ## Examples
@@ -178,7 +191,28 @@ The variable `stats.runCount` persists between executions and increments each ti
 
 ---
 
-## Output modes
+### 5. Cross-workflow shared counter
+
+Count total webhook hits across every workflow on the instance:
+
+**In each workflow that receives a webhook — Increment shared counter:**
+- Operation: `Increment Variable`
+- Scope: `Cross-Workflow (Shared)`
+- Namespace: `global_stats`
+- Key: `webhook_hits`
+- Amount: `1`
+- Initialize If Missing: `true`
+- Initial Value: `0`
+
+**In a reporting workflow — Read the counter:**
+- Operation: `Get Variable`
+- Scope: `Cross-Workflow (Shared)`
+- Namespace: `global_stats`
+- Key: `webhook_hits`
+
+Because the database is shared, all workflows see and update the same value.
+
+---
 
 | Mode | Description |
 |---|---|
@@ -209,11 +243,9 @@ Workflow Global and Node Local variables use n8n's static data, which is:
 
 - **Suitable for:** counters, feature flags, small state objects, per-user values in low-traffic bots
 - **Not suitable for:** high-concurrency write operations (e.g., simultaneously updating the same counter from hundreds of parallel executions)
-- **Not cross-workflow:** variables are scoped to the workflow they belong to, not shared globally across all workflows
-
-For high-volume or high-concurrency state, consider using a database node (Redis, Postgres, MongoDB) instead.
+- **Not cross-workflow:** Workflow Global and Node Local variables are scoped to the workflow they belong to. Use the **Cross-Workflow (Shared)** scope to share state across workflows.
 
-Future versions of this node may add built-in Redis, Postgres, or n8n Data Tables backends.
+For high-volume or high-concurrency state, consider using a dedicated database node (Redis, Postgres, MongoDB) instead.
 
 ---
 

package/dist/nodes/Variable/Variable.node.js

@@ -4,6 +4,7 @@ exports.Variable = void 0;
 const n8n_workflow_1 = require("n8n-workflow");
 const valueParser_1 = require("./helpers/valueParser");
 const storage_1 = require("./helpers/storage");
+const dbStorage_1 = require("./helpers/dbStorage");
 class Variable {
     constructor() {
         this.description = {
@@ -68,6 +69,11 @@ class Variable {
                             value: 'customNamespace',
                             description: 'Workflow global storage with a custom namespace expression.',
                         },
+                        {
+                            name: 'Cross-Workflow (Shared)',
+                            value: 'crossWorkflow',
+                            description: 'Variables are stored in a shared local database file and are accessible across ALL workflows on this instance.',
+                        },
                     ],
                     default: 'workflowGlobal',
                     description: 'Where to store the variable',
@@ -102,7 +108,7 @@ class Variable {
                     description: 'Namespace to organize variables. Supports expressions like economy_{{$json.guild.id}}.',
                     displayOptions: {
                         show: {
-                            scope: ['workflowGlobal', 'nodeLocal'],
+                            scope: ['workflowGlobal', 'nodeLocal', 'crossWorkflow'],
                         },
                     },
                 },
@@ -347,9 +353,9 @@ class Variable {
                     name: 'includeMetadata',
                     type: 'boolean',
                     default: false,
-                    description: 'Whether to store and expose createdAt/updatedAt/type metadata for workflow-global and node-local variables',
+                    description: 'Whether to store and expose createdAt/updatedAt/type metadata for variables',
                     displayOptions: {
-                        show: { scope: ['workflowGlobal', 'nodeLocal', 'customNamespace'] },
+                        show: { scope: ['workflowGlobal', 'nodeLocal', 'customNamespace', 'crossWorkflow'] },
                     },
                 },
             ],
@@ -410,6 +416,7 @@ function resolveNamespace(ctx, scope, i) {
 // ─── Operation dispatcher ─────────────────────────────────────────────────────
 function executeOperation(ctx, operation, scope, namespace, itemJson, i, includeMetadata) {
     const isLocal = scope === 'localExecution';
+    const isDb = scope === 'crossWorkflow';
     const storagePath = isLocal
         ? ctx.getNodeParameter('localStoragePath', i, '_variables')
         : '';
@@ -417,6 +424,8 @@ function executeOperation(ctx, operation, scope, namespace, itemJson, i, include
     const get = (key) => {
         if (isLocal)
             return (0, storage_1.localGetVariable)(itemJson, storagePath, namespace, key);
+        if (isDb)
+            return (0, dbStorage_1.dbGetVariable)(namespace, key)?.value;
         const entry = (0, storage_1.staticGetVariable)(getStaticData(ctx, scope), namespace, key);
         return entry?.value;
     };
@@ -424,6 +433,9 @@ function executeOperation(ctx, operation, scope, namespace, itemJson, i, include
         if (isLocal) {
             (0, storage_1.localSetVariable)(itemJson, storagePath, namespace, key, value);
         }
+        else if (isDb) {
+            (0, dbStorage_1.dbSetVariable)(namespace, key, value, typeName, includeMetadata);
+        }
         else {
             (0, storage_1.staticSetVariable)(getStaticData(ctx, scope), namespace, key, value, typeName, includeMetadata);
         }
@@ -431,16 +443,28 @@ function executeOperation(ctx, operation, scope, namespace, itemJson, i, include
     const del = (key) => {
         if (isLocal)
             return (0, storage_1.localDeleteVariable)(itemJson, storagePath, namespace, key);
+        if (isDb)
+            return (0, dbStorage_1.dbDeleteVariable)(namespace, key);
         return (0, storage_1.staticDeleteVariable)(getStaticData(ctx, scope), namespace, key);
     };
     const has = (key) => {
         if (isLocal)
             return (0, storage_1.localHasVariable)(itemJson, storagePath, namespace, key);
+        if (isDb)
+            return (0, dbStorage_1.dbHasVariable)(namespace, key);
         return (0, storage_1.staticHasVariable)(getStaticData(ctx, scope), namespace, key);
     };
     const list = () => {
         if (isLocal)
             return (0, storage_1.localListVariables)(itemJson, storagePath, namespace);
+        if (isDb) {
+            const raw = (0, dbStorage_1.dbListVariables)(namespace);
+            const result = {};
+            for (const [k, entry] of Object.entries(raw)) {
+                result[k] = entry.value;
+            }
+            return result;
+        }
         const raw = (0, storage_1.staticListVariables)(getStaticData(ctx, scope), namespace);
         // unwrap StoredVariableEntry to plain values
         const result = {};
@@ -452,6 +476,8 @@ function executeOperation(ctx, operation, scope, namespace, itemJson, i, include
     const clear = () => {
         if (isLocal)
             return (0, storage_1.localClearNamespace)(itemJson, storagePath, namespace);
+        if (isDb)
+            return (0, dbStorage_1.dbClearNamespace)(namespace);
         return (0, storage_1.staticClearNamespace)(getStaticData(ctx, scope), namespace);
     };
     const scopeLabel = scope;

package/dist/nodes/Variable/helpers/dbStorage.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Cross-workflow variable storage backed by a local JSON file.
+ *
+ * The file is auto-created at:
+ *   ${N8N_USER_FOLDER ?? ~/.n8n}/n8n-nodes-variable-data.json
+ *
+ * No configuration is required. Writes are performed atomically (write to a
+ * temporary file, then rename) to prevent data corruption on unexpected
+ * process exit. No native dependencies are needed.
+ */
+import type { StoredVariableEntry } from './types';
+export declare function dbGetVariable(namespace: string, key: string): StoredVariableEntry | undefined;
+export declare function dbSetVariable(namespace: string, key: string, value: unknown, typeName: string, includeMetadata: boolean): void;
+export declare function dbDeleteVariable(namespace: string, key: string): boolean;
+export declare function dbHasVariable(namespace: string, key: string): boolean;
+export declare function dbListVariables(namespace: string): Record<string, StoredVariableEntry>;
+export declare function dbClearNamespace(namespace: string): number;

package/dist/nodes/Variable/helpers/dbStorage.js

@@ -0,0 +1,128 @@
+"use strict";
+/**
+ * Cross-workflow variable storage backed by a local JSON file.
+ *
+ * The file is auto-created at:
+ *   ${N8N_USER_FOLDER ?? ~/.n8n}/n8n-nodes-variable-data.json
+ *
+ * No configuration is required. Writes are performed atomically (write to a
+ * temporary file, then rename) to prevent data corruption on unexpected
+ * process exit. No native dependencies are needed.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dbGetVariable = dbGetVariable;
+exports.dbSetVariable = dbSetVariable;
+exports.dbDeleteVariable = dbDeleteVariable;
+exports.dbHasVariable = dbHasVariable;
+exports.dbListVariables = dbListVariables;
+exports.dbClearNamespace = dbClearNamespace;
+const fs_1 = __importDefault(require("fs"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const DATA_FILENAME = 'n8n-nodes-variable-data.json';
+function getDataPath() {
+    const userFolder = process.env['N8N_USER_FOLDER'] ?? path_1.default.join(os_1.default.homedir(), '.n8n');
+    try {
+        if (!fs_1.default.existsSync(userFolder)) {
+            fs_1.default.mkdirSync(userFolder, { recursive: true });
+        }
+    }
+    catch {
+        // If the n8n user folder can't be created, fall back to the OS temp dir
+        return path_1.default.join(os_1.default.tmpdir(), DATA_FILENAME);
+    }
+    return path_1.default.join(userFolder, DATA_FILENAME);
+}
+function readData() {
+    const dataPath = getDataPath();
+    try {
+        const content = fs_1.default.readFileSync(dataPath, 'utf-8');
+        const parsed = JSON.parse(content);
+        if (typeof parsed === 'object' && parsed !== null && !Array.isArray(parsed)) {
+            return parsed;
+        }
+    }
+    catch {
+        // File doesn't exist yet or is corrupt — start fresh
+    }
+    return {};
+}
+function writeData(data) {
+    const dataPath = getDataPath();
+    const tmpPath = `${dataPath}.tmp`;
+    fs_1.default.writeFileSync(tmpPath, JSON.stringify(data), 'utf-8');
+    fs_1.default.renameSync(tmpPath, dataPath);
+}
+// ─── CRUD operations ─────────────────────────────────────────────────────────
+function dbGetVariable(namespace, key) {
+    const data = readData();
+    const entry = data[namespace]?.[key];
+    if (!entry)
+        return undefined;
+    return {
+        value: entry.value,
+        type: entry.type,
+        createdAt: entry.created_at,
+        updatedAt: entry.updated_at,
+    };
+}
+function dbSetVariable(namespace, key, value, typeName, includeMetadata) {
+    const data = readData();
+    if (!data[namespace]) {
+        data[namespace] = {};
+    }
+    const now = new Date().toISOString();
+    if (includeMetadata) {
+        const existing = data[namespace][key];
+        data[namespace][key] = {
+            value,
+            type: typeName,
+            // Preserve original created_at on updates
+            created_at: existing?.created_at ?? now,
+            updated_at: now,
+        };
+    }
+    else {
+        data[namespace][key] = { value };
+    }
+    writeData(data);
+}
+function dbDeleteVariable(namespace, key) {
+    const data = readData();
+    if (!data[namespace] || !(key in data[namespace])) {
+        return false;
+    }
+    delete data[namespace][key];
+    writeData(data);
+    return true;
+}
+function dbHasVariable(namespace, key) {
+    const data = readData();
+    return Object.prototype.hasOwnProperty.call(data[namespace] ?? {}, key);
+}
+function dbListVariables(namespace) {
+    const data = readData();
+    const ns = data[namespace] ?? {};
+    const result = {};
+    for (const [k, entry] of Object.entries(ns)) {
+        result[k] = {
+            value: entry.value,
+            type: entry.type,
+            createdAt: entry.created_at,
+            updatedAt: entry.updated_at,
+        };
+    }
+    return result;
+}
+function dbClearNamespace(namespace) {
+    const data = readData();
+    const count = Object.keys(data[namespace] ?? {}).length;
+    if (count > 0) {
+        delete data[namespace];
+        writeData(data);
+    }
+    return count;
+}

package/dist/nodes/Variable/helpers/types.d.ts

@@ -1,4 +1,4 @@
-export type VariableScope = 'localExecution' | 'workflowGlobal' | 'nodeLocal' | 'customNamespace';
+export type VariableScope = 'localExecution' | 'workflowGlobal' | 'nodeLocal' | 'customNamespace' | 'crossWorkflow';
 export type VariableOperation = 'set' | 'get' | 'delete' | 'has' | 'list' | 'clear' | 'increment' | 'decrement' | 'appendToArray' | 'mergeObject' | 'toggleBoolean';
 export type ValueType = 'string' | 'number' | 'boolean' | 'json' | 'array' | 'object' | 'auto';
 export type OutputMode = 'preserveAndAdd' | 'resultOnly' | 'addField';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "n8n-nodes-variable",
-  "version": "1.0.7",
+  "version": "1.0.9",
   "description": "Local and global scoped variables for n8n workflows",
   "keywords": [
     "n8n-community-node-package",