n8n-nodes-variable 1.0.9 → 1.1.0

package/README.md

@@ -13,6 +13,7 @@ The **Variable** node lets you store, retrieve, update, and delete named variabl
 - **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
+- **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
 
 ---
 
@@ -107,6 +108,31 @@ The file is **created automatically on first use** — no setup or dependencies
 
 > **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.
+
 ---
 
 ## Examples
@@ -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/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.9",
+  "version": "1.1.0",
   "description": "Local and global scoped variables for n8n workflows",
   "keywords": [
     "n8n-community-node-package",
@@ -32,7 +32,9 @@
   ],
   "n8n": {
     "n8nNodesApiVersion": 1,
-    "credentials": [],
+    "credentials": [
+      "dist/credentials/N8nVariableNodeApi.credentials.js"
+    ],
     "nodes": [
       "dist/nodes/Variable/Variable.node.js"
     ]