n8n-nodes-variable 1.0.6

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

@@ -0,0 +1,14 @@
+import type { IDataObject } from 'n8n-workflow';
+import type { StoredVariableEntry } from './types';
+export declare function staticGetVariable(staticData: IDataObject, namespace: string, key: string): StoredVariableEntry | undefined;
+export declare function staticSetVariable(staticData: IDataObject, namespace: string, key: string, value: unknown, typeName: string, includeMetadata: boolean): void;
+export declare function staticDeleteVariable(staticData: IDataObject, namespace: string, key: string): boolean;
+export declare function staticHasVariable(staticData: IDataObject, namespace: string, key: string): boolean;
+export declare function staticListVariables(staticData: IDataObject, namespace: string): Record<string, StoredVariableEntry>;
+export declare function staticClearNamespace(staticData: IDataObject, namespace: string): number;
+export declare function localGetVariable(itemJson: IDataObject, storagePath: string, namespace: string, key: string): unknown;
+export declare function localSetVariable(itemJson: IDataObject, storagePath: string, namespace: string, key: string, value: unknown): void;
+export declare function localDeleteVariable(itemJson: IDataObject, storagePath: string, namespace: string, key: string): boolean;
+export declare function localHasVariable(itemJson: IDataObject, storagePath: string, namespace: string, key: string): boolean;
+export declare function localListVariables(itemJson: IDataObject, storagePath: string, namespace: string): Record<string, unknown>;
+export declare function localClearNamespace(itemJson: IDataObject, storagePath: string, namespace: string): number;

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

@@ -0,0 +1,138 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.staticGetVariable = staticGetVariable;
+exports.staticSetVariable = staticSetVariable;
+exports.staticDeleteVariable = staticDeleteVariable;
+exports.staticHasVariable = staticHasVariable;
+exports.staticListVariables = staticListVariables;
+exports.staticClearNamespace = staticClearNamespace;
+exports.localGetVariable = localGetVariable;
+exports.localSetVariable = localSetVariable;
+exports.localDeleteVariable = localDeleteVariable;
+exports.localHasVariable = localHasVariable;
+exports.localListVariables = localListVariables;
+exports.localClearNamespace = localClearNamespace;
+const PACKAGE_KEY = 'n8nNodesVariable';
+// ─── Static data store helpers (Workflow Global / Node Local) ────────────────
+function getPackageStore(staticData) {
+    if (!staticData[PACKAGE_KEY]) {
+        staticData[PACKAGE_KEY] = { namespaces: {} };
+    }
+    return staticData[PACKAGE_KEY];
+}
+function getNamespaceStore(pkg, namespace) {
+    if (!pkg.namespaces[namespace]) {
+        pkg.namespaces[namespace] = { variables: {} };
+    }
+    return pkg.namespaces[namespace];
+}
+function staticGetVariable(staticData, namespace, key) {
+    const pkg = getPackageStore(staticData);
+    const ns = pkg.namespaces[namespace];
+    if (!ns)
+        return undefined;
+    return ns.variables[key];
+}
+function staticSetVariable(staticData, namespace, key, value, typeName, includeMetadata) {
+    const pkg = getPackageStore(staticData);
+    const ns = getNamespaceStore(pkg, namespace);
+    const now = new Date().toISOString();
+    const existing = ns.variables[key];
+    const entry = { value };
+    if (includeMetadata) {
+        entry.type = typeName;
+        entry.createdAt = existing?.createdAt ?? now;
+        entry.updatedAt = now;
+    }
+    ns.variables[key] = entry;
+}
+function staticDeleteVariable(staticData, namespace, key) {
+    const pkg = getPackageStore(staticData);
+    const ns = pkg.namespaces[namespace];
+    if (!ns || !(key in ns.variables))
+        return false;
+    delete ns.variables[key];
+    return true;
+}
+function staticHasVariable(staticData, namespace, key) {
+    const pkg = getPackageStore(staticData);
+    const ns = pkg.namespaces[namespace];
+    return !!(ns && key in ns.variables);
+}
+function staticListVariables(staticData, namespace) {
+    const pkg = getPackageStore(staticData);
+    const ns = pkg.namespaces[namespace];
+    if (!ns)
+        return {};
+    return { ...ns.variables };
+}
+function staticClearNamespace(staticData, namespace) {
+    const pkg = getPackageStore(staticData);
+    const ns = pkg.namespaces[namespace];
+    if (!ns)
+        return 0;
+    const count = Object.keys(ns.variables).length;
+    ns.variables = {};
+    return count;
+}
+// ─── Local execution (item JSON) store helpers ───────────────────────────────
+function getLocalNamespaceContainer(itemJson, storagePath, namespace) {
+    if (!itemJson[storagePath] || typeof itemJson[storagePath] !== 'object') {
+        itemJson[storagePath] = {};
+    }
+    const root = itemJson[storagePath];
+    if (!root[namespace] || typeof root[namespace] !== 'object') {
+        root[namespace] = {};
+    }
+    return root[namespace];
+}
+function localGetVariable(itemJson, storagePath, namespace, key) {
+    const container = itemJson[storagePath];
+    if (!container)
+        return undefined;
+    const ns = container[namespace];
+    if (!ns)
+        return undefined;
+    return ns[key];
+}
+function localSetVariable(itemJson, storagePath, namespace, key, value) {
+    const ns = getLocalNamespaceContainer(itemJson, storagePath, namespace);
+    ns[key] = value;
+}
+function localDeleteVariable(itemJson, storagePath, namespace, key) {
+    const container = itemJson[storagePath];
+    if (!container)
+        return false;
+    const ns = container[namespace];
+    if (!ns || !(key in ns))
+        return false;
+    delete ns[key];
+    return true;
+}
+function localHasVariable(itemJson, storagePath, namespace, key) {
+    const container = itemJson[storagePath];
+    if (!container)
+        return false;
+    const ns = container[namespace];
+    return !!(ns && key in ns);
+}
+function localListVariables(itemJson, storagePath, namespace) {
+    const container = itemJson[storagePath];
+    if (!container)
+        return {};
+    const ns = container[namespace];
+    if (!ns)
+        return {};
+    return { ...ns };
+}
+function localClearNamespace(itemJson, storagePath, namespace) {
+    const container = itemJson[storagePath];
+    if (!container)
+        return 0;
+    const ns = container[namespace];
+    if (!ns)
+        return 0;
+    const count = Object.keys(ns).length;
+    container[namespace] = {};
+    return count;
+}

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

@@ -0,0 +1,30 @@
+export type VariableScope = 'localExecution' | 'workflowGlobal' | 'nodeLocal' | 'customNamespace';
+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';
+export interface StoredVariableEntry {
+    value: unknown;
+    type?: string;
+    createdAt?: string;
+    updatedAt?: string;
+}
+export interface VariableNamespace {
+    variables: Record<string, StoredVariableEntry>;
+}
+export interface PackageStaticStore {
+    namespaces: Record<string, VariableNamespace>;
+}
+export interface OperationResult {
+    operation: string;
+    scope: string;
+    namespace: string;
+    key?: string;
+    value?: unknown;
+    previousValue?: unknown;
+    exists?: boolean;
+    deleted?: boolean;
+    keys?: string[];
+    variables?: Record<string, unknown>;
+    count?: number;
+    cleared?: boolean;
+}

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

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,20 @@
+import type { ValueType } from './types';
+/**
+ * Validates a variable key or namespace string.
+ * Throws a plain Error (to be wrapped by the node as NodeOperationError).
+ */
+export declare function validateKey(key: string, label?: string): void;
+export declare function validateNamespace(ns: string): void;
+/**
+ * Parse a raw string value into the typed JavaScript value specified by valueType.
+ */
+export declare function parseValueByType(rawValue: unknown, valueType: ValueType): unknown;
+/** Parse a JSON string safely, throwing a user-friendly error on failure. */
+export declare function safeJsonParse(str: string): unknown;
+/** Infer the type name from a runtime value. */
+export declare function inferValueType(value: unknown): string;
+/**
+ * Deep-merge source object into target object.
+ * Only handles plain objects at each level; other values are overwritten.
+ */
+export declare function deepMerge(target: Record<string, unknown>, source: Record<string, unknown>): Record<string, unknown>;

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

@@ -0,0 +1,124 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateKey = validateKey;
+exports.validateNamespace = validateNamespace;
+exports.parseValueByType = parseValueByType;
+exports.safeJsonParse = safeJsonParse;
+exports.inferValueType = inferValueType;
+exports.deepMerge = deepMerge;
+/** Keys that would cause prototype pollution — always rejected. */
+const DANGEROUS_KEYS = new Set(['__proto__', 'constructor', 'prototype']);
+/**
+ * Validates a variable key or namespace string.
+ * Throws a plain Error (to be wrapped by the node as NodeOperationError).
+ */
+function validateKey(key, label = 'Key') {
+    const trimmed = key.trim();
+    if (trimmed.length === 0) {
+        throw new Error(`${label} must not be empty.`);
+    }
+    if (DANGEROUS_KEYS.has(trimmed)) {
+        throw new Error(`${label} "${trimmed}" is not allowed for security reasons.`);
+    }
+}
+function validateNamespace(ns) {
+    const trimmed = ns.trim();
+    if (trimmed.length === 0) {
+        throw new Error('Namespace must not be empty.');
+    }
+    if (DANGEROUS_KEYS.has(trimmed)) {
+        throw new Error(`Namespace "${trimmed}" is not allowed for security reasons.`);
+    }
+}
+/**
+ * Parse a raw string value into the typed JavaScript value specified by valueType.
+ */
+function parseValueByType(rawValue, valueType) {
+    if (valueType === 'auto') {
+        return rawValue;
+    }
+    const str = String(rawValue ?? '');
+    switch (valueType) {
+        case 'string':
+            return str;
+        case 'number': {
+            const n = Number(str);
+            if (str.trim() === '' || !Number.isFinite(n)) {
+                throw new Error(`Value "${str}" cannot be converted to a valid number. Got: ${n}`);
+            }
+            return n;
+        }
+        case 'boolean': {
+            const lower = str.toLowerCase().trim();
+            if (lower === 'true' || lower === '1' || lower === 'yes')
+                return true;
+            if (lower === 'false' || lower === '0' || lower === 'no')
+                return false;
+            // If rawValue is already boolean, use it directly
+            if (typeof rawValue === 'boolean')
+                return rawValue;
+            throw new Error(`Value "${str}" cannot be converted to a boolean. Use true/false/1/0/yes/no.`);
+        }
+        case 'json': {
+            return safeJsonParse(str);
+        }
+        case 'array': {
+            const parsed = safeJsonParse(str);
+            if (!Array.isArray(parsed)) {
+                throw new Error(`Value must be a JSON array (e.g. [1, 2, 3]). Got: ${typeof parsed}`);
+            }
+            return parsed;
+        }
+        case 'object': {
+            const parsed = safeJsonParse(str);
+            if (typeof parsed !== 'object' ||
+                parsed === null ||
+                Array.isArray(parsed)) {
+                throw new Error(`Value must be a plain JSON object (e.g. {"key": "value"}). Got: ${Array.isArray(parsed) ? 'array' : typeof parsed}`);
+            }
+            return parsed;
+        }
+        default:
+            return str;
+    }
+}
+/** Parse a JSON string safely, throwing a user-friendly error on failure. */
+function safeJsonParse(str) {
+    try {
+        return JSON.parse(str);
+    }
+    catch {
+        throw new Error(`Invalid JSON: ${str.slice(0, 100)}${str.length > 100 ? '…' : ''}`);
+    }
+}
+/** Infer the type name from a runtime value. */
+function inferValueType(value) {
+    if (value === null)
+        return 'null';
+    if (Array.isArray(value))
+        return 'array';
+    return typeof value;
+}
+/**
+ * Deep-merge source object into target object.
+ * Only handles plain objects at each level; other values are overwritten.
+ */
+function deepMerge(target, source) {
+    const result = { ...target };
+    for (const key of Object.keys(source)) {
+        const srcVal = source[key];
+        const tgtVal = target[key];
+        if (typeof srcVal === 'object' &&
+            srcVal !== null &&
+            !Array.isArray(srcVal) &&
+            typeof tgtVal === 'object' &&
+            tgtVal !== null &&
+            !Array.isArray(tgtVal)) {
+            result[key] = deepMerge(tgtVal, srcVal);
+        }
+        else {
+            result[key] = srcVal;
+        }
+    }
+    return result;
+}

package/package.json

@@ -0,0 +1,71 @@
+{
+  "name": "n8n-nodes-variable",
+  "version": "1.0.6",
+  "description": "Local and global scoped variables for n8n workflows",
+  "keywords": [
+    "n8n-community-node-package",
+    "n8n",
+    "variables",
+    "workflow",
+    "state",
+    "discord",
+    "automation"
+  ],
+  "license": "MIT",
+  "author": "Lou",
+  "repository": {
+    "type": "git",
+    "url": ""
+  },
+  "main": "index.js",
+  "scripts": {
+    "build": "tsc && copyfiles -u 1 \"nodes/**/*.svg\" dist/ && copyfiles -u 1 \"nodes/**/*.json\" dist/",
+    "dev": "tsc --watch",
+    "lint": "eslint nodes --ext .ts",
+    "lintfix": "eslint nodes --ext .ts --fix",
+    "format": "prettier nodes --write",
+    "prepublishOnly": "npm run build && npm run lint",
+    "test": "jest --testPathPattern=tests/"
+  },
+  "files": [
+    "dist"
+  ],
+  "n8n": {
+    "n8nNodesApiVersion": 1,
+    "credentials": [],
+    "nodes": [
+      "dist/nodes/Variable/Variable.node.js"
+    ]
+  },
+  "devDependencies": {
+    "@types/jest": "^29.5.12",
+    "@types/node": "^18.19.50",
+    "@typescript-eslint/eslint-plugin": "^6.21.0",
+    "@typescript-eslint/parser": "^6.21.0",
+    "copyfiles": "^2.4.1",
+    "eslint": "^8.57.0",
+    "eslint-plugin-n8n-nodes-base": "^1.16.2",
+    "jest": "^29.7.0",
+    "n8n-workflow": "^1.0.0",
+    "prettier": "^3.3.3",
+    "ts-jest": "^29.2.5",
+    "typescript": "^5.5.4"
+  },
+  "peerDependencies": {
+    "n8n-workflow": "*"
+  },
+  "jest": {
+    "preset": "ts-jest",
+    "testEnvironment": "node",
+    "moduleFileExtensions": [
+      "ts",
+      "js"
+    ],
+    "testMatch": [
+      "**/tests/**/*.test.ts"
+    ],
+    "transform": {
+      "^.+\\.ts$": "ts-jest"
+    }
+  }
+}