n8n-nodes-variable 1.0.6 → 1.0.8

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 SQLite database 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 SQLite database file on the n8n host at:
+
+```
+${N8N_USER_FOLDER ?? ~/.n8n}/n8n-nodes-variable.db
+```
+
+The database and table are **created automatically on first use** — no setup required. Data survives instance restarts and is accessible from any workflow on the same n8n instance. This is ideal for cross-workflow counters, shared feature flags, or any state that multiple workflows need to read and write.
+
+> **Note:** the database 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;
@@ -581,7 +607,8 @@ function opIncrement(ctx, i, namespace, scopeLabel, get, set, has, direction) {
     const initialValue = ctx.getNodeParameter('numericInitialValue', i, 0);
     const opName = direction === 1 ? 'increment' : 'decrement';
     let current;
-    if (!has(key)) {
+    const existed = has(key);
+    if (!existed) {
         if (!initIfMissing) {
             throw new Error(`Variable "${key}" does not exist in namespace "${namespace}". Enable "Initialize If Missing" to create it automatically.`);
         }
@@ -602,7 +629,7 @@ function opIncrement(ctx, i, namespace, scopeLabel, get, set, has, direction) {
         namespace,
         key,
         value: newValue,
-        previousValue: has(key) ? current : undefined,
+        previousValue: existed ? current : undefined,
     };
 }
 function opAppendToArray(ctx, i, namespace, scopeLabel, get, set, has) {
@@ -717,7 +744,10 @@ function buildOutputItem(ctx, originalItem, updatedItemJson, result, outputMode,
         };
     }
     if (outputMode === 'addField') {
-        const fieldName = ctx.getNodeParameter('addFieldName', i, 'value');
+        // For Get Variable, use the dedicated output field name; otherwise use addFieldName
+        const fieldName = result.operation === 'get'
+            ? ctx.getNodeParameter('getOutputFieldName', i, 'value')
+            : ctx.getNodeParameter('addFieldName', i, 'value');
         return {
             json: {
                 ...updatedItemJson,

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

@@ -0,0 +1,16 @@
+/**
+ * Cross-workflow variable storage backed by a local SQLite database.
+ *
+ * The database is auto-created at:
+ *   ${N8N_USER_FOLDER ?? ~/.n8n}/n8n-nodes-variable.db
+ *
+ * No configuration is required — the database file and table are created
+ * automatically on first use and shared across all workflows on the instance.
+ */
+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,137 @@
+"use strict";
+/**
+ * Cross-workflow variable storage backed by a local SQLite database.
+ *
+ * The database is auto-created at:
+ *   ${N8N_USER_FOLDER ?? ~/.n8n}/n8n-nodes-variable.db
+ *
+ * No configuration is required — the database file and table are created
+ * automatically on first use and shared across all workflows on the instance.
+ */
+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 better_sqlite3_1 = __importDefault(require("better-sqlite3"));
+const fs_1 = __importDefault(require("fs"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const DB_FILENAME = 'n8n-nodes-variable.db';
+function getDbPath() {
+    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 we can't create the n8n folder, fall back to the OS temp directory
+        return path_1.default.join(os_1.default.tmpdir(), DB_FILENAME);
+    }
+    return path_1.default.join(userFolder, DB_FILENAME);
+}
+// Singleton connection — reused across all node executions in the same process
+let _db = null;
+function getDb() {
+    if (_db)
+        return _db;
+    const dbPath = getDbPath();
+    _db = new better_sqlite3_1.default(dbPath);
+    // WAL journal mode allows concurrent reads alongside writes
+    _db.pragma('journal_mode = WAL');
+    _db.pragma('foreign_keys = ON');
+    // Auto-create the table if it doesn't exist
+    _db.exec(`
+    CREATE TABLE IF NOT EXISTS variables (
+      namespace  TEXT NOT NULL,
+      key        TEXT NOT NULL,
+      value      TEXT NOT NULL,
+      type       TEXT,
+      created_at TEXT,
+      updated_at TEXT,
+      PRIMARY KEY (namespace, key)
+    )
+  `);
+    return _db;
+}
+// ─── CRUD operations ─────────────────────────────────────────────────────────
+function dbGetVariable(namespace, key) {
+    const db = getDb();
+    const row = db
+        .prepare('SELECT value, type, created_at, updated_at FROM variables WHERE namespace = ? AND key = ?')
+        .get(namespace, key);
+    if (!row)
+        return undefined;
+    return {
+        value: JSON.parse(row.value),
+        type: row.type ?? undefined,
+        createdAt: row.created_at ?? undefined,
+        updatedAt: row.updated_at ?? undefined,
+    };
+}
+function dbSetVariable(namespace, key, value, typeName, includeMetadata) {
+    const db = getDb();
+    const now = new Date().toISOString();
+    const serialized = JSON.stringify(value);
+    if (includeMetadata) {
+        // Preserve the original created_at on conflict
+        db.prepare(`INSERT INTO variables (namespace, key, value, type, created_at, updated_at)
+       VALUES (?, ?, ?, ?, ?, ?)
+       ON CONFLICT(namespace, key) DO UPDATE SET
+         value      = excluded.value,
+         type       = excluded.type,
+         updated_at = excluded.updated_at`).run(namespace, key, serialized, typeName, now, now);
+    }
+    else {
+        db.prepare(`INSERT INTO variables (namespace, key, value, type, created_at, updated_at)
+       VALUES (?, ?, ?, NULL, NULL, NULL)
+       ON CONFLICT(namespace, key) DO UPDATE SET
+         value      = excluded.value,
+         type       = NULL,
+         created_at = NULL,
+         updated_at = NULL`).run(namespace, key, serialized);
+    }
+}
+function dbDeleteVariable(namespace, key) {
+    const db = getDb();
+    const result = db
+        .prepare('DELETE FROM variables WHERE namespace = ? AND key = ?')
+        .run(namespace, key);
+    return result.changes > 0;
+}
+function dbHasVariable(namespace, key) {
+    const db = getDb();
+    const row = db
+        .prepare('SELECT 1 FROM variables WHERE namespace = ? AND key = ? LIMIT 1')
+        .get(namespace, key);
+    return row !== undefined;
+}
+function dbListVariables(namespace) {
+    const db = getDb();
+    const rows = db
+        .prepare('SELECT key, value, type, created_at, updated_at FROM variables WHERE namespace = ? ORDER BY key')
+        .all(namespace);
+    const result = {};
+    for (const row of rows) {
+        result[row.key] = {
+            value: JSON.parse(row.value),
+            type: row.type ?? undefined,
+            createdAt: row.created_at ?? undefined,
+            updatedAt: row.updated_at ?? undefined,
+        };
+    }
+    return result;
+}
+function dbClearNamespace(namespace) {
+    const db = getDb();
+    const result = db
+        .prepare('DELETE FROM variables WHERE namespace = ?')
+        .run(namespace);
+    return result.changes;
+}

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.6",
+  "version": "1.0.8",
   "description": "Local and global scoped variables for n8n workflows",
   "keywords": [
     "n8n-community-node-package",
@@ -38,6 +38,7 @@
     ]
   },
   "devDependencies": {
+    "@types/better-sqlite3": "^7.6.11",
     "@types/jest": "^29.5.12",
     "@types/node": "^18.19.50",
     "@typescript-eslint/eslint-plugin": "^6.21.0",
@@ -54,6 +55,9 @@
   "peerDependencies": {
     "n8n-workflow": "*"
   },
+  "dependencies": {
+    "better-sqlite3": "^9.4.0"
+  },
   "jest": {
     "preset": "ts-jest",
     "testEnvironment": "node",