n8n-nodes-variable 1.0.8 → 1.1.0

package/README.md

@@ -12,7 +12,8 @@ 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
+- **Cross-Workflow (Shared)** — variables are stored in a local JSON file and shared across **all** workflows on this n8n instance
+- **Cross-Workflow (Data Tables)** — variables are stored in n8n's built-in **Data Tables**, visible in the Data Tables UI tab and accessible from any workflow via the n8n API
 
 ---
 
@@ -97,15 +98,40 @@ guild_{{$json.guild.id}} → per-guild settings
 
 ### Cross-Workflow (Shared)
 
-Variables are stored in a SQLite database file on the n8n host at:
+Variables are stored in a JSON file on the n8n host at:
 
 ```
-${N8N_USER_FOLDER ?? ~/.n8n}/n8n-nodes-variable.db
+${N8N_USER_FOLDER ?? ~/.n8n}/n8n-nodes-variable-data.json
 ```
 
-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.
+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 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.
+> **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.
+
+### Cross-Workflow (Data Tables)
+
+Variables are stored as rows in an n8n **Data Table**, making them visible and editable directly in the n8n UI under the **Data Tables** tab.
+
+Each namespace maps to one table named `var_<namespace>` (e.g., namespace `global_stats` → table `var_global_stats`). The table is **created automatically on first use**. Each row stores a `key` and a `value` (JSON-serialised).
+
+#### Prerequisites
+
+1. **Enable the n8n API** — in your n8n instance go to **Settings → API** and create an API key.
+2. **Create a credential** — add a new credential of type **n8n Variable Node API** and enter:
+   - **n8n Instance URL** — the base URL your n8n instance is reachable at *from within the n8n process itself* (e.g. `http://localhost:5678` for local/Docker installs, or `https://your-instance.example.com` for cloud).
+   - **API Key** — the key generated in step 1.
+3. In the Variable node, set **Scope** to **Cross-Workflow (Data Tables)** and select the credential.
+
+#### What gets stored
+
+| Column | Content |
+|---|---|
+| `key` | The variable key string |
+| `value` | The variable value, JSON-serialised (numbers, booleans, arrays, and objects all round-trip correctly) |
+
+> **Tip:** Because the data lives in a real Data Table you can query it with the built-in **n8n Data Table** node, view and edit it in the UI, and use it as a lightweight shared datastore without any external database.
+
+> **Note for Docker users:** HTTP calls made by the Variable node originate from inside the container. Use `http://localhost:5678` (or the container's own hostname/service name in Docker Compose) as the base URL — not the external host address.
 
 ---
 
@@ -214,6 +240,33 @@ Because the database is shared, all workflows see and update the same value.
 
 ---
 
+### 6. Cross-workflow shared counter (Data Tables)
+
+Same counter as example 5, but stored in n8n Data Tables so you can see and edit the value in the UI.
+
+**Prerequisites:** Create an **n8n Variable Node API** credential (see the *Cross-Workflow (Data Tables)* scope section above).
+
+**Increment on each webhook hit:**
+- Operation: `Increment Variable`
+- Scope: `Cross-Workflow (Data Tables)`
+- Credential: *(select your n8n Variable Node API credential)*
+- Namespace: `global_stats`
+- Key: `webhook_hits`
+- Amount: `1`
+- Initialize If Missing: `true`
+- Initial Value: `0`
+
+**Read the counter from any other workflow:**
+- Operation: `Get Variable`
+- Scope: `Cross-Workflow (Data Tables)`
+- Credential: *(same credential)*
+- Namespace: `global_stats`
+- Key: `webhook_hits`
+
+n8n automatically creates a Data Table called `var_global_stats` with `key` and `value` columns. You can inspect or edit the data at any time from the **Data Tables** tab in the n8n sidebar.
+
+---
+
 | Mode | Description |
 |---|---|
 | **Preserve Input + Add Result** _(default)_ | Keep all input fields and add a result object at `variable` (or your chosen field name) |

package/dist/credentials/N8nVariableNodeApi.credentials.d.ts

@@ -0,0 +1,7 @@
+import type { ICredentialType, INodeProperties } from 'n8n-workflow';
+export declare class N8nVariableNodeApi implements ICredentialType {
+    name: string;
+    displayName: string;
+    documentationUrl: string;
+    properties: INodeProperties[];
+}

package/dist/credentials/N8nVariableNodeApi.credentials.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.N8nVariableNodeApi = void 0;
+class N8nVariableNodeApi {
+    constructor() {
+        this.name = 'n8nVariableNodeApi';
+        this.displayName = 'n8n Variable Node API';
+        this.documentationUrl = 'https://docs.n8n.io/api/authentication/';
+        this.properties = [
+            {
+                displayName: 'n8n Instance URL',
+                name: 'baseUrl',
+                type: 'string',
+                default: 'http://localhost:5678',
+                placeholder: 'https://your-n8n-instance.example.com',
+                required: true,
+                description: 'The base URL of your n8n instance (no trailing slash)',
+            },
+            {
+                displayName: 'API Key',
+                name: 'apiKey',
+                type: 'string',
+                typeOptions: { password: true },
+                default: '',
+                required: true,
+                description: 'Your n8n API key. Generate one in Settings → API.',
+            },
+        ];
+    }
+}
+exports.N8nVariableNodeApi = N8nVariableNodeApi;

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

@@ -5,10 +5,22 @@ 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");
+const dataTableStorage_1 = require("./helpers/dataTableStorage");
 class Variable {
     constructor() {
         this.description = {
             displayName: 'Variable',
+            credentials: [
+                {
+                    name: 'n8nVariableNodeApi',
+                    required: false,
+                    displayOptions: {
+                        show: {
+                            scope: ['crossWorkflowDataTable'],
+                        },
+                    },
+                },
+            ],
             name: 'variable',
             icon: 'file:variable.svg',
             group: ['transform'],
@@ -74,6 +86,11 @@ class Variable {
                             value: 'crossWorkflow',
                             description: 'Variables are stored in a shared local database file and are accessible across ALL workflows on this instance.',
                         },
+                        {
+                            name: 'Cross-Workflow (Data Tables)',
+                            value: 'crossWorkflowDataTable',
+                            description: 'Variables are stored in n8n Data Tables (visible in the Data Tables tab). Requires n8n API credentials.',
+                        },
                     ],
                     default: 'workflowGlobal',
                     description: 'Where to store the variable',
@@ -108,7 +125,7 @@ class Variable {
                     description: 'Namespace to organize variables. Supports expressions like economy_{{$json.guild.id}}.',
                     displayOptions: {
                         show: {
-                            scope: ['workflowGlobal', 'nodeLocal', 'crossWorkflow'],
+                            scope: ['workflowGlobal', 'nodeLocal', 'crossWorkflow', 'crossWorkflowDataTable'],
                         },
                     },
                 },
@@ -353,7 +370,7 @@ class Variable {
                     name: 'includeMetadata',
                     type: 'boolean',
                     default: false,
-                    description: 'Whether to store and expose createdAt/updatedAt/type metadata for variables',
+                    description: 'Whether to store and expose createdAt/updatedAt/type metadata for variables (not supported for Data Tables scope)',
                     displayOptions: {
                         show: { scope: ['workflowGlobal', 'nodeLocal', 'customNamespace', 'crossWorkflow'] },
                     },
@@ -398,7 +415,13 @@ async function processItem(ctx, item, i) {
     (0, valueParser_1.validateNamespace)(resolvedNamespace);
     // Clone item JSON so we don't mutate the input
     const itemJson = { ...item.json };
-    const result = executeOperation(ctx, operation, scope, resolvedNamespace, itemJson, i, includeMetadata);
+    let result;
+    if (scope === 'crossWorkflowDataTable') {
+        result = await executeDataTableOperation(ctx, operation, resolvedNamespace, i);
+    }
+    else {
+        result = executeOperation(ctx, operation, scope, resolvedNamespace, itemJson, i, includeMetadata);
+    }
     return buildOutputItem(ctx, item, itemJson, result, outputMode, i);
 }
 // ─── Namespace resolution ─────────────────────────────────────────────────────
@@ -502,6 +525,215 @@ function getStaticData(ctx, scope) {
         return ctx.getWorkflowStaticData('node');
     return ctx.getWorkflowStaticData('global');
 }
+// ─── Data Table scope async executor ─────────────────────────────────────────
+async function executeDataTableOperation(ctx, operation, namespace, i) {
+    const scopeLabel = 'crossWorkflowDataTable';
+    switch (operation) {
+        case 'set': {
+            const key = getKey(ctx, i);
+            const valueType = ctx.getNodeParameter('valueType', i, 'auto');
+            const rawValue = ctx.getNodeParameter('value', i, '');
+            const overwrite = ctx.getNodeParameter('overwriteExisting', i, true);
+            if (!overwrite) {
+                const exists = await (0, dataTableStorage_1.dtHasVariable)(ctx, namespace, key);
+                if (exists) {
+                    throw new Error(`Variable "${key}" already exists in namespace "${namespace}". Enable "Overwrite If Exists" to update it.`);
+                }
+            }
+            const parsed = (0, valueParser_1.parseValueByType)(rawValue, valueType);
+            const typeName = valueType === 'auto' ? (0, valueParser_1.inferValueType)(parsed) : valueType;
+            await (0, dataTableStorage_1.dtSetVariable)(ctx, namespace, key, parsed, typeName, false);
+            return { operation: 'set', scope: scopeLabel, namespace, key, value: parsed };
+        }
+        case 'get': {
+            const key = getKey(ctx, i);
+            const exists = await (0, dataTableStorage_1.dtHasVariable)(ctx, namespace, key);
+            const useDefault = ctx.getNodeParameter('useDefaultValue', i, false);
+            const defaultValue = ctx.getNodeParameter('defaultValue', i, '');
+            let value;
+            if (exists) {
+                const entry = await (0, dataTableStorage_1.dtGetVariable)(ctx, namespace, key);
+                value = entry?.value;
+            }
+            else if (useDefault) {
+                value = defaultValue;
+            }
+            else {
+                throw new Error(`Variable "${key}" does not exist in namespace "${namespace}". Enable "Use Default Value" or create the variable first.`);
+            }
+            return { operation: 'get', scope: scopeLabel, namespace, key, value, exists };
+        }
+        case 'delete': {
+            const key = getKey(ctx, i);
+            const existed = await (0, dataTableStorage_1.dtHasVariable)(ctx, namespace, key);
+            const deleted = await (0, dataTableStorage_1.dtDeleteVariable)(ctx, namespace, key);
+            return { operation: 'delete', scope: scopeLabel, namespace, key, exists: existed, deleted };
+        }
+        case 'has': {
+            const key = getKey(ctx, i);
+            const exists = await (0, dataTableStorage_1.dtHasVariable)(ctx, namespace, key);
+            return { operation: 'has', scope: scopeLabel, namespace, key, exists };
+        }
+        case 'list': {
+            const includeValues = ctx.getNodeParameter('includeValues', i, true);
+            const raw = await (0, dataTableStorage_1.dtListVariables)(ctx, namespace);
+            const keys = Object.keys(raw);
+            const result = {
+                operation: 'list',
+                scope: scopeLabel,
+                namespace,
+                keys,
+                count: keys.length,
+            };
+            if (includeValues) {
+                const vars = {};
+                for (const [k, entry] of Object.entries(raw)) {
+                    vars[k] = entry.value;
+                }
+                result.variables = vars;
+            }
+            return result;
+        }
+        case 'clear': {
+            const confirmation = ctx.getNodeParameter('clearConfirmation', i, '');
+            if (confirmation.trim() !== 'CLEAR') {
+                throw new Error('Clear cancelled: you must type CLEAR (uppercase) in the Confirmation field to proceed.');
+            }
+            const count = await (0, dataTableStorage_1.dtClearNamespace)(ctx, namespace);
+            return { operation: 'clear', scope: scopeLabel, namespace, count, cleared: true };
+        }
+        case 'increment':
+        case 'decrement': {
+            const key = getKey(ctx, i);
+            const amount = ctx.getNodeParameter('incrementAmount', i, 1);
+            const initIfMissing = ctx.getNodeParameter('initIfMissingNumeric', i, true);
+            const initialValue = ctx.getNodeParameter('numericInitialValue', i, 0);
+            const direction = operation === 'increment' ? 1 : -1;
+            let current;
+            const existed = await (0, dataTableStorage_1.dtHasVariable)(ctx, namespace, key);
+            if (!existed) {
+                if (!initIfMissing) {
+                    throw new Error(`Variable "${key}" does not exist in namespace "${namespace}". Enable "Initialize If Missing" to create it automatically.`);
+                }
+                current = initialValue;
+            }
+            else {
+                const entry = await (0, dataTableStorage_1.dtGetVariable)(ctx, namespace, key);
+                const existing = entry?.value;
+                if (typeof existing !== 'number' || !Number.isFinite(existing)) {
+                    throw new Error(`Cannot ${operation} "${key}": current value is not a finite number (got ${typeof existing}: ${JSON.stringify(existing)}).`);
+                }
+                current = existing;
+            }
+            const newValue = current + direction * Math.abs(amount);
+            await (0, dataTableStorage_1.dtSetVariable)(ctx, namespace, key, newValue, 'number', false);
+            return {
+                operation,
+                scope: scopeLabel,
+                namespace,
+                key,
+                value: newValue,
+                previousValue: existed ? current : undefined,
+            };
+        }
+        case 'appendToArray': {
+            const key = getKey(ctx, i);
+            const valueType = ctx.getNodeParameter('valueType', i, 'auto');
+            const rawValue = ctx.getNodeParameter('value', i, '');
+            const initIfMissing = ctx.getNodeParameter('initIfMissingArray', i, true);
+            let arr;
+            const exists = await (0, dataTableStorage_1.dtHasVariable)(ctx, namespace, key);
+            if (!exists) {
+                if (!initIfMissing) {
+                    throw new Error(`Variable "${key}" does not exist. Enable "Initialize If Missing" to create an empty array automatically.`);
+                }
+                arr = [];
+            }
+            else {
+                const entry = await (0, dataTableStorage_1.dtGetVariable)(ctx, namespace, key);
+                const existing = entry?.value;
+                if (!Array.isArray(existing)) {
+                    throw new Error(`Cannot append to "${key}": existing value is not an array (got ${typeof existing}).`);
+                }
+                arr = [...existing];
+            }
+            const parsed = (0, valueParser_1.parseValueByType)(rawValue, valueType);
+            arr.push(parsed);
+            await (0, dataTableStorage_1.dtSetVariable)(ctx, namespace, key, arr, 'array', false);
+            return { operation: 'appendToArray', scope: scopeLabel, namespace, key, value: arr };
+        }
+        case 'mergeObject': {
+            const key = getKey(ctx, i);
+            const objectJsonRaw = ctx.getNodeParameter('objectJson', i, '{}');
+            const useDeepMerge = ctx.getNodeParameter('deepMerge', i, false);
+            const initIfMissing = ctx.getNodeParameter('initIfMissingObject', i, true);
+            let incoming;
+            try {
+                const p = typeof objectJsonRaw === 'object' && objectJsonRaw !== null
+                    ? objectJsonRaw
+                    : JSON.parse(String(objectJsonRaw));
+                if (typeof p !== 'object' || p === null || Array.isArray(p))
+                    throw new Error('not a plain object');
+                incoming = p;
+            }
+            catch {
+                throw new Error(`Object (JSON) must be a plain object. Got: ${String(objectJsonRaw).slice(0, 100)}`);
+            }
+            let base;
+            const exists = await (0, dataTableStorage_1.dtHasVariable)(ctx, namespace, key);
+            if (!exists) {
+                if (!initIfMissing) {
+                    throw new Error(`Variable "${key}" does not exist. Enable "Initialize If Missing" to create an empty object automatically.`);
+                }
+                base = {};
+            }
+            else {
+                const entry = await (0, dataTableStorage_1.dtGetVariable)(ctx, namespace, key);
+                const existing = entry?.value;
+                if (typeof existing !== 'object' || existing === null || Array.isArray(existing)) {
+                    throw new Error(`Cannot merge into "${key}": existing value is not a plain object (got ${Array.isArray(existing) ? 'array' : typeof existing}).`);
+                }
+                base = { ...existing };
+            }
+            const merged = useDeepMerge ? (0, valueParser_1.deepMerge)(base, incoming) : { ...base, ...incoming };
+            await (0, dataTableStorage_1.dtSetVariable)(ctx, namespace, key, merged, 'object', false);
+            return { operation: 'mergeObject', scope: scopeLabel, namespace, key, value: merged };
+        }
+        case 'toggleBoolean': {
+            const key = getKey(ctx, i);
+            const initIfMissing = ctx.getNodeParameter('initIfMissingBoolean', i, true);
+            const initialValue = ctx.getNodeParameter('booleanInitialValue', i, false);
+            let current;
+            const exists = await (0, dataTableStorage_1.dtHasVariable)(ctx, namespace, key);
+            if (!exists) {
+                if (!initIfMissing) {
+                    throw new Error(`Variable "${key}" does not exist. Enable "Initialize If Missing" to create it automatically.`);
+                }
+                current = initialValue;
+            }
+            else {
+                const entry = await (0, dataTableStorage_1.dtGetVariable)(ctx, namespace, key);
+                const existing = entry?.value;
+                if (typeof existing !== 'boolean') {
+                    throw new Error(`Cannot toggle "${key}": existing value is not a boolean (got ${typeof existing}: ${JSON.stringify(existing)}).`);
+                }
+                current = existing;
+            }
+            const newValue = !current;
+            await (0, dataTableStorage_1.dtSetVariable)(ctx, namespace, key, newValue, 'boolean', false);
+            return {
+                operation: 'toggleBoolean',
+                scope: scopeLabel,
+                namespace,
+                key,
+                value: newValue,
+                previousValue: current,
+            };
+        }
+        default:
+            throw new Error(`Unknown operation: ${operation}`);
+    }
+}
 // ─── Individual operations ────────────────────────────────────────────────────
 function opSet(ctx, i, namespace, scopeLabel, get, set, has) {
     const key = getKey(ctx, i);

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

@@ -0,0 +1,8 @@
+import type { IExecuteFunctions } from 'n8n-workflow';
+import type { StoredVariableEntry } from './types';
+export declare function dtGetVariable(ctx: IExecuteFunctions, namespace: string, key: string): Promise<StoredVariableEntry | undefined>;
+export declare function dtSetVariable(ctx: IExecuteFunctions, namespace: string, key: string, value: unknown, _typeName: string, _includeMetadata: boolean): Promise<void>;
+export declare function dtDeleteVariable(ctx: IExecuteFunctions, namespace: string, key: string): Promise<boolean>;
+export declare function dtHasVariable(ctx: IExecuteFunctions, namespace: string, key: string): Promise<boolean>;
+export declare function dtListVariables(ctx: IExecuteFunctions, namespace: string): Promise<Record<string, StoredVariableEntry>>;
+export declare function dtClearNamespace(ctx: IExecuteFunctions, namespace: string): Promise<number>;

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

@@ -0,0 +1,162 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dtGetVariable = dtGetVariable;
+exports.dtSetVariable = dtSetVariable;
+exports.dtDeleteVariable = dtDeleteVariable;
+exports.dtHasVariable = dtHasVariable;
+exports.dtListVariables = dtListVariables;
+exports.dtClearNamespace = dtClearNamespace;
+// In-process cache: namespace -> tableId
+const tableIdCache = new Map();
+function makeTableName(namespace) {
+    // Sanitize namespace to be URL-safe for table names
+    return `var_${namespace.replace(/[^a-zA-Z0-9_-]/g, '_')}`;
+}
+function makeKeyFilter(key) {
+    return {
+        type: 'and',
+        filters: [{ columnName: 'key', condition: 'eq', value: key }],
+    };
+}
+async function apiRequest(ctx, method, path, body, qs) {
+    const creds = await ctx.getCredentials('n8nVariableNodeApi');
+    const baseUrl = String(creds.baseUrl).replace(/\/+$/, '');
+    const apiKey = String(creds.apiKey);
+    const options = {
+        method,
+        url: `${baseUrl}/api/v1${path}`,
+        headers: {
+            'X-N8N-API-KEY': apiKey,
+        },
+        json: true,
+    };
+    if (qs !== undefined) {
+        options.qs = qs;
+    }
+    if (body !== undefined) {
+        options.body = body;
+    }
+    return ctx.helpers.httpRequest(options);
+}
+async function findTableId(ctx, namespace) {
+    const tName = makeTableName(namespace);
+    const resp = await apiRequest(ctx, 'GET', '/data-tables', undefined, { limit: 250 });
+    const tables = resp.data ?? [];
+    return tables.find((t) => t.name === tName)?.id;
+}
+async function getOrCreateTable(ctx, namespace, forceRefresh = false) {
+    if (!forceRefresh && tableIdCache.has(namespace)) {
+        return tableIdCache.get(namespace);
+    }
+    const existing = await findTableId(ctx, namespace);
+    if (existing) {
+        tableIdCache.set(namespace, existing);
+        return existing;
+    }
+    // Create the table with key + value columns
+    const created = await apiRequest(ctx, 'POST', '/data-tables', {
+        name: makeTableName(namespace),
+        columns: [
+            { name: 'key', type: 'string' },
+            { name: 'value', type: 'string' },
+        ],
+    });
+    const newId = created.id;
+    tableIdCache.set(namespace, newId);
+    return newId;
+}
+async function dtGetVariable(ctx, namespace, key) {
+    const tableId = await getOrCreateTable(ctx, namespace);
+    const resp = await apiRequest(ctx, 'GET', `/data-tables/${tableId}/rows`, undefined, {
+        filter: JSON.stringify(makeKeyFilter(key)),
+        limit: 1,
+    });
+    const rows = resp.data ?? [];
+    if (rows.length === 0)
+        return undefined;
+    const row = rows[0];
+    try {
+        return { value: JSON.parse(String(row['value'])) };
+    }
+    catch {
+        return { value: row['value'] };
+    }
+}
+async function dtSetVariable(ctx, namespace, key, value, _typeName, _includeMetadata) {
+    const tableId = await getOrCreateTable(ctx, namespace);
+    const serialized = JSON.stringify(value);
+    // Try update first; if nothing was updated, insert
+    const updateResult = await apiRequest(ctx, 'PATCH', `/data-tables/${tableId}/rows/update`, {
+        filter: makeKeyFilter(key),
+        data: { value: serialized },
+        returnData: true,
+        dryRun: false,
+    });
+    const updatedRows = Array.isArray(updateResult) ? updateResult : [];
+    if (updatedRows.length === 0) {
+        await apiRequest(ctx, 'POST', `/data-tables/${tableId}/rows`, {
+            data: [{ key, value: serialized }],
+            returnType: 'count',
+        });
+    }
+}
+async function dtDeleteVariable(ctx, namespace, key) {
+    const exists = await dtHasVariable(ctx, namespace, key);
+    if (!exists)
+        return false;
+    const tableId = await getOrCreateTable(ctx, namespace);
+    await apiRequest(ctx, 'DELETE', `/data-tables/${tableId}/rows/delete`, {
+        filter: makeKeyFilter(key),
+    });
+    return true;
+}
+async function dtHasVariable(ctx, namespace, key) {
+    const tableId = await getOrCreateTable(ctx, namespace);
+    const resp = await apiRequest(ctx, 'GET', `/data-tables/${tableId}/rows`, undefined, {
+        filter: JSON.stringify(makeKeyFilter(key)),
+        limit: 1,
+    });
+    const rows = resp.data ?? [];
+    return rows.length > 0;
+}
+async function dtListVariables(ctx, namespace) {
+    const tableId = await getOrCreateTable(ctx, namespace);
+    const allRows = [];
+    let cursor;
+    do {
+        const qs = { limit: 250 };
+        if (cursor)
+            qs['cursor'] = cursor;
+        const resp = await apiRequest(ctx, 'GET', `/data-tables/${tableId}/rows`, undefined, qs);
+        const typed = resp;
+        allRows.push(...(typed.data ?? []));
+        cursor = typed.nextCursor;
+    } while (cursor);
+    const result = {};
+    for (const row of allRows) {
+        const k = String(row['key'] ?? '');
+        if (!k)
+            continue;
+        try {
+            result[k] = { value: JSON.parse(String(row['value'])) };
+        }
+        catch {
+            result[k] = { value: row['value'] };
+        }
+    }
+    return result;
+}
+async function dtClearNamespace(ctx, namespace) {
+    const tableId = await findTableId(ctx, namespace);
+    if (!tableId)
+        return 0;
+    // Count rows before deleting
+    const vars = await dtListVariables(ctx, namespace);
+    const count = Object.keys(vars).length;
+    if (count > 0) {
+        // Delete the entire table; it will be recreated on next use
+        await apiRequest(ctx, 'DELETE', `/data-tables/${tableId}`);
+        tableIdCache.delete(namespace);
+    }
+    return count;
+}

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

@@ -1,11 +1,12 @@
 /**
- * Cross-workflow variable storage backed by a local SQLite database.
+ * Cross-workflow variable storage backed by a local JSON file.
  *
- * The database is auto-created at:
- *   ${N8N_USER_FOLDER ?? ~/.n8n}/n8n-nodes-variable.db
+ * The file is auto-created at:
+ *   ${N8N_USER_FOLDER ?? ~/.n8n}/n8n-nodes-variable-data.json
  *
- * No configuration is required — the database file and table are created
- * automatically on first use and shared across all workflows on the instance.
+ * 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;

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

@@ -1,12 +1,13 @@
 "use strict";
 /**
- * Cross-workflow variable storage backed by a local SQLite database.
+ * Cross-workflow variable storage backed by a local JSON file.
  *
- * The database is auto-created at:
- *   ${N8N_USER_FOLDER ?? ~/.n8n}/n8n-nodes-variable.db
+ * The file is auto-created at:
+ *   ${N8N_USER_FOLDER ?? ~/.n8n}/n8n-nodes-variable-data.json
  *
- * No configuration is required — the database file and table are created
- * automatically on first use and shared across all workflows on the instance.
+ * 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 };
@@ -18,12 +19,11 @@ 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 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)) {
@@ -31,107 +31,98 @@ function getDbPath() {
         }
     }
     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);
+        // 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, DB_FILENAME);
+    return path_1.default.join(userFolder, DATA_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;
+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 db = getDb();
-    const row = db
-        .prepare('SELECT value, type, created_at, updated_at FROM variables WHERE namespace = ? AND key = ?')
-        .get(namespace, key);
-    if (!row)
+    const data = readData();
+    const entry = data[namespace]?.[key];
+    if (!entry)
         return undefined;
     return {
-        value: JSON.parse(row.value),
-        type: row.type ?? undefined,
-        createdAt: row.created_at ?? undefined,
-        updatedAt: row.updated_at ?? undefined,
+        value: entry.value,
+        type: entry.type,
+        createdAt: entry.created_at,
+        updatedAt: entry.updated_at,
     };
 }
 function dbSetVariable(namespace, key, value, typeName, includeMetadata) {
-    const db = getDb();
+    const data = readData();
+    if (!data[namespace]) {
+        data[namespace] = {};
+    }
     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);
+        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 {
-        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);
+        data[namespace][key] = { value };
     }
+    writeData(data);
 }
 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;
+    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 db = getDb();
-    const row = db
-        .prepare('SELECT 1 FROM variables WHERE namespace = ? AND key = ? LIMIT 1')
-        .get(namespace, key);
-    return row !== undefined;
+    const data = readData();
+    return Object.prototype.hasOwnProperty.call(data[namespace] ?? {}, key);
 }
 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 data = readData();
+    const ns = data[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,
+    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 db = getDb();
-    const result = db
-        .prepare('DELETE FROM variables WHERE namespace = ?')
-        .run(namespace);
-    return result.changes;
+    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' | 'crossWorkflow';
+export type VariableScope = 'localExecution' | 'workflowGlobal' | 'nodeLocal' | 'customNamespace' | 'crossWorkflow' | 'crossWorkflowDataTable';
 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.8",
+  "version": "1.1.0",
   "description": "Local and global scoped variables for n8n workflows",
   "keywords": [
     "n8n-community-node-package",
@@ -32,13 +32,14 @@
   ],
   "n8n": {
     "n8nNodesApiVersion": 1,
-    "credentials": [],
+    "credentials": [
+      "dist/credentials/N8nVariableNodeApi.credentials.js"
+    ],
     "nodes": [
       "dist/nodes/Variable/Variable.node.js"
     ]
   },
   "devDependencies": {
-    "@types/better-sqlite3": "^7.6.11",
     "@types/jest": "^29.5.12",
     "@types/node": "^18.19.50",
     "@typescript-eslint/eslint-plugin": "^6.21.0",
@@ -55,9 +56,6 @@
   "peerDependencies": {
     "n8n-workflow": "*"
   },
-  "dependencies": {
-    "better-sqlite3": "^9.4.0"
-  },
   "jest": {
     "preset": "ts-jest",
     "testEnvironment": "node",